[libcxx][ranges] Add ranges::take_view.

[zoecarver]

Go through https://libcxx.llvm.org/Contributing.html and fix what needs to be fixed.

Added proper "enable_borrowed_range".

[zoecarver]

libcxx/include/__iterator/counted_iterator.h

58

Review note: this file and the one below (common_view.h) have/will be updated with the changes shown here in other patches.

libcxx/include/__ranges/take_view.h

54

Chris, before you ask, I did try to factor this out into a static member function, but ran into a couple of issues (first, I had to inline size, second, it didn't work well for move only views).

😉

136

We move __end in the other constructor, why not here too? We don't use it later.

[cjdb]

libcxx/include/__ranges/take_view.h

19

Please replace with the specific algorithms you use.

44

Can be const.

54

Now that you've brought it to my attention... ;)

• why did you need to inline size?
• why doesn't it work well for move-only views?

111

Hmm... I just realised that if we're going to be using algorithms here, we should definitely be using ranges overloads. You won't be stepping on my turf if you implement the min/max family.

136

If it's passed by value we should be allowed to do so.

160

Oooooh nice, all_t.

[ldionne]

I have not looked at the tests yet.

libcxx/include/__ranges/take_view.h

35

[[no_unique_address]]

41

requires default_initializable<_View>, and also _LIBCPP_HIDE_FROM_ABI.

74

using _Difference = range_difference_t<const _View>;? (applies above)

111

It seems conforming to me to use std::min here, no?

127

[[no_unique_address]]

133

_LIBCPP_HIDE_FROM_ABI

136

I say we should move it. I don't see a reason either.

155

You could use __rhs.__end_ here, which would avoid making a copy of the sentinel (base() makes a copy). Same applies above.

[zoecarver]

libcxx/include/__ranges/take_view.h

44

__count? I don't really see how that benefits us... it's passed by value...

54

Well, because we really want a static function that we pass __base_ to, otherwise that kind of defeats the purpose of deducing _View vs const _View.

If we're passing __base_ we both lose size and have to move it into the function and then out of the function when we put it back into the member. That seems like an unreasonable cost.

111

I think that's a bit out of scope for my current timeline. Is there an observable difference?

136

Why did the standard do it below and not here, though? Was that just an oversight? CC @tcanens

[zoecarver]

libcxx/include/__ranges/take_view.h

155

That really should be inlined. But fair enough. I'm going to make it public so I can do that for lhs too.

[zoecarver]

Apply review comments.

[ldionne]

LGTM mod comments and passing CI!

libcxx/include/__ranges/take_view.h

54

I think this would work:

template <class _Self>
_LIBCPP_HIDE_FROM_ABI
static constexpr auto __begin(_Self& __self) {
  using _MaybeConstView = _If<is_const_v<_Self>, _View const, _View>;
  if constexpr (sized_range< _MaybeConstView >) {
        if constexpr (random_access_range<_MaybeConstView>) {
          return ranges::begin(__self.__base_);
        } else {
          using _DifferenceT = range_difference_t<_MaybeConstView>;
          auto __size = __self.size();
          return counted_iterator{ranges::begin(__self.__base_), static_cast<_DifferenceT>(__size)};
        }
      } else {
        return counted_iterator{ranges::begin(__self.__base_), __self.__count_};
      }
}

_LIBCPP_HIDE_FROM_ABI
constexpr auto begin() requires (!__simple_view<_View>) {
  return take_view::__begin(*this);
}

// etc...

I'm still not sure whether I like that better than matching the spec 1:1. I'll leave it to you to decide @zoecarver .

77

In all those counted_iterator constructions, the spec uses direct-initialization instead of list-initialization. I don't think this ever matters because there can't be a narrowing conversion from _DifferenceT to the argument of counted_iterator::counted_iterator (both types should always be exactly iter_difference_t<iterator_t<_View>>), but we might as well follow the spec.

155

Depending on what the _View's copy constructor does, it might not be possible to inline it, I think. I would definitely not rely on that, at least.

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

24

Can you make this more minimal? For example, I think you could provide only begin() const as a member function.

Also, since you're using it in a bunch of places, perhaps you could put it in a types.h helper header in this directory? That would be a simple way to remove some duplication.

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

97

Could you add a one-liner to each test to make it very obvious which branch of the if constexpr you're testing? Something as simple as:

// sized_range && random_access

133–143

I'm not sure what coverage this is adding. Consider removing if it doesn't add anything.

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

18

#include <concepts>

46

Alternatively, you could leave at file scope. Whatever you prefer.

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

64

You never actually default-construct an object here. Could you do that? Ideally, you'd then test that base() has been default-initialized, and that the size() is 0 (which you could do best by creating a view that has non-zero size when default-constructed).

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

97

Same comment as for begin() w.r.t. which if branch we're testing.

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

113

You want to test this version (N == size-of-the-range) for const too.

118

You want to test this version (N > size-of-the-range) for non-const too.

[zoecarver]

Apply remaining review comments.

Note: I'm rebasing on main instead of counted_iterator so the CI passes. It's just easier this way.

[zoecarver]

Actually push the change with the addressed feedback :P

[zoecarver]

Move Copyable and ContiguousView into the local header. They were conflicting with types that transform_view uses. I'll move them into test_ranges.h in a later commit.

[cjdb]

Please add range concept conformance tests before merging.

libcxx/include/__ranges/take_view.h

44

If we start by making everything const and then remove it for only the objects we intend to modify, we're better-documenting our intention. Put another way: we shouldn't need a reason to provide const: we should have a good reason to omit const.

54

@ldionne's got what I had in mind. I like it because it keeps the complex logic in one place and makes sure that any bugs only have one source of manifestation.

111

In general: yes, there is an observable difference. std::min requires that its parameters meet Cpp17LessThanComparable, whereas std::ranges::min requires that its parameters model totally_ordered_with. Since we're comparing integers, I don't think it's going to be an observable difference.

Could you please at least add a FIXME so I remember to clean it up one day?

libcxx/test/support/test_iterators.h

701

Why is this being deleted?

[zoecarver]

libcxx/test/support/test_iterators.h

701

These archetypes are meant to represent the minimum requirements of an iterator. C++20 input iterators are not required to be default constructible, therefore our C++20 input iterator archetype should not be default constructible.

[• Quuxplusone]

libcxx/test/support/test_iterators.h

701

@zoecarver: FWIW, your archetype philosophy makes sense to me; but I wish this change to massively shared test code were done in a separate patch, not bundled in with this counted_iterator feature. (IIUC, all our existing tests are completely apathetic to this change: this change is neither required, nor harmful, to any existing test.)

libcxx/test/support/test_range.h

58

woot! :) but also, please land this as a separate NFC commit (and you can just go ahead and do that).
Bonus points if you clean up the > > on lines 26, 35, 42, 51, and the spelling mistake on line 17, while you're at it.

[zoecarver]

Add a comment with a TODO for the ranges::min.

Reset the changes to test_range.h.

Rebase on main.

[zoecarver]

Add UNSUPPORTED: libcpp-has-no-incomplete-ranges. Rebase. Add range conformance tests.

libcxx/docs/Status/RangesPaper.csv

 [move.sentinel],,[predef.iterators],Unassigned,Not started
 [common.iterator],,"| [iterator.concepts]
 | [iterator.cust.swap]
 | [iterator.cust.move]",Zoe Carver,✅
 [default.sentinels],std::default_sentinel_t.,No dependencies,Zoe Carver,✅
 [counted.iterator],,"| [iterator.concepts]
 | [iterator.cust.swap]
 | [iterator.cust.move]
-| [default.sentinels]",Zoe Carver,In Progress
+| [default.sentinels]",Zoe Carver,✅
 [stream.iterators],,[default.sentinels],Unassigned,Not started
 `[range.access] <http://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
 | ranges::rend
 | ranges::crbegin

 | ranges::borrowed_iterator_t
 | ranges::borrowed_subrange_t","| [range.range]
 | [range.subrange]",Christopher Di Bella,✅
 `[range.all] <http://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,✅
 `[range.view.ref] <http://wg21.link/range.view>`_,`ref-view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,✅
 `[range.filter] <http://wg21.link/range.filter>`_,filter_view,[range.all],Louis Dionne,Not started
 `[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Louis Dionne,Not started
-`[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,In Progress
+`[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,✅
 `[range.join] <http://wg21.link/range.join>`_,join_view,[range.all],Christopher Di Bella,Not started
 `[range.empty] <http://wg21.link/range.empty>`_,`empty_view <https://reviews.llvm.org/D103208>`_,[view.interface],Zoe Carver,✅
 `[range.single] <http://wg21.link/range.single>`_,single_view,[view.interface],Zoe Carver,In Progress
 `[range.split] <http://wg21.link/range.split>`_,split_view,[range.all],Unassigned,Not started
 `[range.counted] <http://wg21.link/range.counted>`_,view::counted,[range.subrange],Zoe Carver,Not started
 `[range.common] <http://wg21.link/range.common>`_,common_view,[range.all],Zoe Carver,✅
 `[range.reverse] <http://wg21.link/range.reverse>`_,reverse_view,[range.all],Unassigned,Not started

libcxx/include/CMakeLists.txt

set(files
   __functional/unwrap_ref.h
   __functional/weak_result_type.h
   __hash_table
   __iterator/access.h
   __iterator/advance.h
   __iterator/back_insert_iterator.h
   __iterator/common_iterator.h
   __iterator/concepts.h
+  __iterator/counted_iterator.h
   __iterator/data.h
   __iterator/default_sentinel.h
   __iterator/distance.h
   __iterator/empty.h
   __iterator/erase_if_container.h
   __iterator/front_insert_iterator.h
   __iterator/incrementable_traits.h
   __iterator/insert_iterator.h
set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/non_propagating_cache.h
   __ranges/ref_view.h
+  __ranges/take_view.h
   __ranges/size.h
   __ranges/subrange.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
   __support/android/locale_bionic.h

libcxx/include/__iterator/counted_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_COUNTED_ITERATOR_H
+#define _LIBCPP___ITERATOR_COUNTED_ITERATOR_H
+
+#include <__config>
+#include <__debug>
+#include <__iterator/concepts.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iter_swap.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
+#include <concepts>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+template<class>
+struct __counted_iterator_concept {};
+
+template<class _Iter>
+  requires requires { typename _Iter::iterator_concept; }
+struct __counted_iterator_concept<_Iter> {
+  using iterator_concept = typename _Iter::iterator_concept;
+};
+
+template<class>
+struct __counted_iterator_category {};
+
+template<class _Iter>
+  requires requires { typename _Iter::iterator_category; }
+struct __counted_iterator_category<_Iter> {
+  using iterator_category = typename _Iter::iterator_category;
+};
+
+template<class>
+struct __counted_iterator_value_type {};
+
+template<indirectly_readable _Iter>
+struct __counted_iterator_value_type<_Iter> {
+  using value_type = iter_value_t<_Iter>;
+};
+
+template<input_or_output_iterator _Iter>
+class counted_iterator
+  : public __counted_iterator_concept<_Iter>
+  , public __counted_iterator_category<_Iter>
+  , public __counted_iterator_value_type<_Iter>
+{
+public:
+  [[no_unique_address]] _Iter __current_ = _Iter();
+  iter_difference_t<_Iter> __count_ = 0;
+
+  using iterator_type = _Iter;
+  using difference_type = iter_difference_t<_Iter>;
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator() requires default_initializable<_Iter> = default;
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator(_Iter __iter, iter_difference_t<_Iter> __n)
+   : __current_(_VSTD::move(__iter)), __count_(__n) {
+    _LIBCPP_ASSERT(__n >= 0, "__n must not be negative.");
+  }
+
+  template<class _I2>
+    requires convertible_to<const _I2&, _Iter>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator(const counted_iterator<_I2>& __other)
+   : __current_(__other.__current_), __count_(__other.__count_) {}
+
+  template<class _I2>
+    requires assignable_from<_Iter&, const _I2&>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator& operator=(const counted_iterator<_I2>& __other) {
+    __current_ = __other.__current_;
+    __count_ = __other.__count_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr const _Iter& base() const& { return __current_; }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr _Iter base() && { return _VSTD::move(__current_); }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr iter_difference_t<_Iter> count() const noexcept { return __count_; }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr decltype(auto) operator*() {
+    _LIBCPP_ASSERT(__count_ > 0, "Iterator is equal to or past end.");
+    return *__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr decltype(auto) operator*() const
+    requires __dereferenceable<const _Iter>
+  {
+    _LIBCPP_ASSERT(__count_ > 0, "Iterator is equal to or past end.");
+    return *__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator->() const noexcept
+    requires contiguous_iterator<_Iter>
+  {
+    return _VSTD::to_address(__current_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator& operator++() {
+    _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
+    ++__current_;
+    --__count_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  decltype(auto) operator++(int) {
+    _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
+    --__count_;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try { return __current_++; }
+    catch(...) { ++__count_; throw; }
+#else
+    return __current_++;
+#endif // _LIBCPP_NO_EXCEPTIONS
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator operator++(int)
+    requires forward_iterator<_Iter>
+  {
+    _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
+    counted_iterator __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator& operator--()
+    requires bidirectional_iterator<_Iter>
+  {
+    --__current_;
+    ++__count_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator operator--(int)
+    requires bidirectional_iterator<_Iter>
+  {
+    counted_iterator __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator operator+(iter_difference_t<_Iter> __n) const
+    requires random_access_iterator<_Iter>
+  {
+    return counted_iterator(__current_ + __n, __count_ - __n);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr counted_iterator operator+(
+    iter_difference_t<_Iter> __n, const counted_iterator& __x)
+    requires random_access_iterator<_Iter>
+  {
+    return __x + __n;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator& operator+=(iter_difference_t<_Iter> __n)
+    requires random_access_iterator<_Iter>
+  {
+    _LIBCPP_ASSERT(__n <= __count_, "Cannot advance iterator past end.");
+    __current_ += __n;
+    __count_ -= __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator operator-(iter_difference_t<_Iter> __n) const
+    requires random_access_iterator<_Iter>
+  {
+    return counted_iterator(__current_ - __n, __count_ + __n);
+  }
+
+  template<common_with<_Iter> _I2>
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr iter_difference_t<_I2> operator-(
+    const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs)
+  {
+    return __rhs.__count_ - __lhs.__count_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr iter_difference_t<_Iter> operator-(
+    const counted_iterator& __lhs, default_sentinel_t)
+  {
+    return -__lhs.__count_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr iter_difference_t<_Iter> operator-(
+    default_sentinel_t, const counted_iterator& __rhs)
+  {
+    return __rhs.__count_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr counted_iterator& operator-=(iter_difference_t<_Iter> __n)
+    requires random_access_iterator<_Iter>
+  {
+    _LIBCPP_ASSERT(-__n <= __count_, "Cannot advance iterator back before begin.");
+    __current_ -= __n;
+    __count_ += __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr decltype(auto) operator[](iter_difference_t<_Iter> __n) const
+    requires random_access_iterator<_Iter>
+  {
+    _LIBCPP_ASSERT(__n < __count_, "Subscript argument must be less than size.");
+    return __current_[__n];
+  }
+
+  template<common_with<_Iter> _I2>
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr bool operator==(
+    const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs)
+  {
+    return __lhs.__count_ == __rhs.__count_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr bool operator==(
+    const counted_iterator& __lhs, default_sentinel_t)
+  {
+    return __lhs.__count_ == 0;
+  }
+
+// TODO: implement this once three_way_comparable is landed.
+//   template<common_with<_Iter> _I2>
+//   friend constexpr strong_ordering operator<=>(
+//     const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs);
+
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const counted_iterator& __i)
+    noexcept(noexcept(ranges::iter_move(__i.__current_)))
+      requires input_iterator<_Iter>
+  {
+    _LIBCPP_ASSERT(__i.__count_ > 0, "Iterator must not be past end of range.");
+    return ranges::iter_move(__i.__current_);
+  }
+
+  template<indirectly_swappable<_Iter> _I2>
+  _LIBCPP_HIDE_FROM_ABI
+  friend constexpr void iter_swap(const counted_iterator& __x, const counted_iterator<_I2>& __y)
+    noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
+  {
+    _LIBCPP_ASSERT(__x.__count_ > 0 && __y.__count_ > 0,
+                   "Iterators must not be past end of range.");
+    return ranges::iter_swap(__x.__current_, __y.__current_);
+  }
+};
+
+template<input_iterator _Iter>
+  requires same_as<_ITER_TRAITS<_Iter>, iterator_traits<_Iter>>
+struct iterator_traits<counted_iterator<_Iter>> : iterator_traits<_Iter> {
+  using pointer = conditional_t<contiguous_iterator<_Iter>,
+                                add_pointer_t<iter_reference_t<_Iter>>, void>;
+};
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ITERATOR_COUNTED_ITERATOR_H

libcxx/include/__ranges/take_view.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___RANGES_TAKE_VIEW_H
+#define _LIBCPP___RANGES_TAKE_VIEW_H
+
+#include <__algorithm/min.h>
+#include <__config>
+#include <__iterator/counted_iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/view_interface.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  template<view _View>
+  class take_view : public view_interface<take_view<_View>> {
+    [[no_unique_address]] _View __base_ = _View();
+    range_difference_t<_View> __count_ = 0;
+
+    template<bool> class __sentinel;
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    take_view() requires default_initializable<_View> = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr take_view(_View __base, range_difference_t<_View> __count)
+      : __base_(_VSTD::move(__base)), __count_(__count) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _View base() && { return _VSTD::move(__base_); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto begin() requires (!__simple_view<_View>) {
+      if constexpr (sized_range<_View>) {
+        if constexpr (random_access_range<_View>) {
+          return ranges::begin(__base_);
+        } else {
+          using _DifferenceT = range_difference_t<_View>;
+          auto __size = size();
+          return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
+        }
+      } else {
+        return counted_iterator(ranges::begin(__base_), __count_);
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto begin() const requires range<const _View> {
+      if constexpr (sized_range<const _View>) {
+        if constexpr (random_access_range<const _View>) {
+          return ranges::begin(__base_);
+        } else {
+          using _DifferenceT = range_difference_t<const _View>;
+          auto __size = size();
+          return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
+        }
+      } else {
+        return counted_iterator(ranges::begin(__base_), __count_);
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto end() requires (!__simple_view<_View>) {
+      if constexpr (sized_range<_View>) {
+        if constexpr (random_access_range<_View>) {
+          return ranges::begin(__base_) + size();
+        } else {
+          return default_sentinel;
+        }
+      } else {
+        return __sentinel<false>{ranges::end(__base_)};
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto end() const requires range<const _View> {
+      if constexpr (sized_range<const _View>) {
+        if constexpr (random_access_range<const _View>) {
+          return ranges::begin(__base_) + size();
+        } else {
+          return default_sentinel;
+        }
+      } else {
+        return __sentinel<true>{ranges::end(__base_)};
+      }
+    }
+
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto size() requires sized_range<_View> {
+      auto __n = ranges::size(__base_);
+      return _VSTD::min(__n, static_cast<decltype(__n)>(__count_));
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto size() const requires sized_range<const _View> {
+      auto __n = ranges::size(__base_);
+      return _VSTD::min(__n, static_cast<decltype(__n)>(__count_));
+    }
+  };
+
+  template<view _View>
+  template<bool _Const>
+  class take_view<_View>::__sentinel {
+    using _Base = __maybe_const<_Const, _View>;
+    template<bool _OtherConst>
+    using _Iter = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
+    [[no_unique_address]] sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+    template<bool>
+    friend class take_view<_View>::__sentinel;
+
+public:
+    _LIBCPP_HIDE_FROM_ABI
+    __sentinel() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(_VSTD::move(__end)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __sentinel(__sentinel<!_Const> __s)
+      requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+      : __end_(_VSTD::move(__s.__end_)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr sentinel_t<_Base> base() const { return __end_; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
+      return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
+    }
+
+    template<bool _OtherConst = !_Const>
+      requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
+      return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
+    }
+  };
+
+  template<class _Range>
+  take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>;
+
+  template<class _Tp>
+  inline constexpr bool enable_borrowed_range<take_view<_Tp>> = enable_borrowed_range<_Tp>;
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_TAKE_VIEW_H

libcxx/include/iterator

 
 template <class Iterator>   // constexpr in C++17
 constexpr  move_iterator<Iterator> make_move_iterator(const Iterator& i);
 
 // [default.sentinel], default sentinel
 struct default_sentinel_t;
 inline constexpr default_sentinel_t default_sentinel{};
 
+// [iterators.counted], counted iterators
+template<input_or_output_iterator I> class counted_iterator;
+
+template<input_iterator I>
+  requires see below
+  struct iterator_traits<counted_iterator<I>>;
+
 template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
 class istream_iterator
     : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17
 {
 public:
     typedef input_iterator_tag           iterator_category;
     typedef T                            value_type;
     typedef Distance                     difference_type;

 #include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/access.h>
 #include <__iterator/advance.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/common_iterator.h>
 #include <__iterator/concepts.h>
+#include <__iterator/counted_iterator.h>
 #include <__iterator/data.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/distance.h>
 #include <__iterator/empty.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/front_insert_iterator.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/insert_iterator.h>

libcxx/include/module.modulemap

module __iterator {
       module access                { private header "__iterator/access.h" }
       module advance               {
         private header "__iterator/advance.h"
         export __function_like
       }
       module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
       module common_iterator       { private header "__iterator/common_iterator.h" }
       module concepts              { private header "__iterator/concepts.h" }
+      module counted_iterator      { private header "__iterator/counted_iterator.h" }
       module data                  { private header "__iterator/data.h" }
       module default_sentinel      { private header "__iterator/default_sentinel.h" }
       module distance              { private header "__iterator/distance.h" }
       module empty                 { private header "__iterator/empty.h" }
       module erase_if_container    { private header "__iterator/erase_if_container.h" }
       module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
       module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
       module insert_iterator       { private header "__iterator/insert_iterator.h" }
module __ranges {
       module empty                  { private header "__ranges/empty.h"                 }
       module empty_view             { private header "__ranges/empty_view.h"            }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h"           }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module ref_view               { private header "__ranges/ref_view.h"              }
       module size                   { private header "__ranges/size.h"                  }
       module subrange               { private header "__ranges/subrange.h"              }
+      module take_view              { private header "__ranges/take_view.h"             }
       module transform_view         { private header "__ranges/transform_view.h"        }
       module view_interface         { private header "__ranges/view_interface.h"        }
     }
   }
   module ratio {
     header "ratio"
     export *
   }

libcxx/include/ranges

namespace std::ranges {
 
   // [range.common], common view
   template<view V>
     requires (!common_range<V> && copyable<iterator_t<V>>)
   class common_view;
 
   template<class T>
   inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
+
+   // [range.take], take view
+  template<view> class take_view;
+
+  template<class T>
+  inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/ref_view.h>
+#include <__ranges/take_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>

libcxx/test/libcxx/diagnostics/detail.headers/iterator/counted_iterator.module.verify.cpp

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__iterator/counted_iterator.h'}}
+#include <__iterator/counted_iterator.h>

libcxx/test/libcxx/diagnostics/detail.headers/ranges/take_view.module.verify.cpp

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/take_view.h'}}
+#include <__ranges/take_view.h>

libcxx/test/std/iterators/predef.iterators/counted.iterator/arrow.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto operator->() const noexcept
+//   requires contiguous_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<class Iter>
+concept ArrowEnabled = requires(Iter& iter) {
+  iter.operator->();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    for (int i = 0; i < 8; ++i, ++iter)
+      assert(iter.operator->() == buffer + i);
+
+    static_assert(noexcept(iter.operator->()));
+  }
+  {
+    const std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    assert(iter.operator->() == buffer);
+
+    static_assert(noexcept(iter.operator->()));
+  }
+
+  {
+      static_assert( ArrowEnabled<std::counted_iterator<contiguous_iterator<int*>>>);
+      static_assert(!ArrowEnabled<std::counted_iterator<random_access_iterator<int*>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/assign.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class I2>
+//   requires assignable_from<I&, const I2&>
+//     constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+class AssignableFromIter
+{
+    int *it_;
+
+public:
+    typedef          std::input_iterator_tag                      iterator_category;
+    typedef int                                                   value_type;
+    typedef typename std::iterator_traits<int *>::difference_type difference_type;
+    typedef int *                                                 pointer;
+    typedef int &                                                 reference;
+
+    constexpr int *base() const {return it_;}
+
+    AssignableFromIter() = default;
+    explicit constexpr AssignableFromIter(int *it) : it_(it) {}
+    constexpr AssignableFromIter(const forward_iterator<int*>& it) : it_(it.base()) {}
+
+    constexpr AssignableFromIter& operator=(const forward_iterator<int*> &other) {
+      it_ = other.base();
+      return *this;
+    }
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr AssignableFromIter& operator++() {++it_; return *this;}
+    constexpr AssignableFromIter operator++(int)
+        {AssignableFromIter tmp(*this); ++(*this); return tmp;}
+};
+
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int *ptr;
+
+  int operator*() { return *ptr; }
+  void operator++(int) { ++ptr; }
+  InputOrOutputArchetype& operator++() { ++ptr; return *this; }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( std::is_assignable_v<std::counted_iterator<forward_iterator<int*>>,
+                                        std::counted_iterator<forward_iterator<int*>>>);
+    static_assert(!std::is_assignable_v<std::counted_iterator<forward_iterator<int*>>,
+                                        std::counted_iterator<random_access_iterator<int*>>>);
+  }
+
+  {
+    std::counted_iterator iter1(AssignableFromIter{buffer}, 8);
+    std::counted_iterator iter2(forward_iterator<int*>{buffer + 2}, 6);
+    assert(iter1.base().base() == buffer);
+    assert(iter1.count() == 8);
+    std::counted_iterator<AssignableFromIter>& result = (iter1 = iter2);
+    assert(&result == &iter1);
+    assert(iter1.base().base() == buffer + 2);
+    assert(iter1.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 = iter2), std::counted_iterator<AssignableFromIter>&);
+  }
+  {
+    std::counted_iterator iter1(AssignableFromIter{buffer}, 8);
+    const std::counted_iterator iter2(forward_iterator<int*>{buffer + 2}, 6);
+    assert(iter1.base().base() == buffer);
+    assert(iter1.count() == 8);
+    std::counted_iterator<AssignableFromIter>& result = (iter1 = iter2);
+    assert(&result == &iter1);
+    assert(iter1.base().base() == buffer + 2);
+    assert(iter1.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 = iter2), std::counted_iterator<AssignableFromIter>&);
+  }
+
+  {
+    std::counted_iterator iter1(InputOrOutputArchetype{buffer}, 8);
+    std::counted_iterator iter2(InputOrOutputArchetype{buffer + 2}, 6);
+    assert(iter1.base().ptr == buffer);
+    assert(iter1.count() == 8);
+    std::counted_iterator<InputOrOutputArchetype>& result = (iter1 = iter2);
+    assert(&result == &iter1);
+    assert(iter1.base().ptr == buffer + 2);
+    assert(iter1.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 = iter2), std::counted_iterator<InputOrOutputArchetype>&);
+  }
+  {
+    std::counted_iterator iter1(InputOrOutputArchetype{buffer}, 8);
+    const std::counted_iterator iter2(InputOrOutputArchetype{buffer + 2}, 6);
+    assert(iter1.base().ptr == buffer);
+    assert(iter1.count() == 8);
+    std::counted_iterator<InputOrOutputArchetype>& result = (iter1 = iter2);
+    assert(&result == &iter1);
+    assert(iter1.base().ptr == buffer + 2);
+    assert(iter1.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 = iter2), std::counted_iterator<InputOrOutputArchetype>&);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/base.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr const I& base() const &;
+// constexpr I base() &&;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int *ptr;
+
+  int operator*() { return *ptr; }
+  void operator++(int) { ++ptr; }
+  InputOrOutputArchetype& operator++() { ++ptr; return *this; }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(iter.base().base() == buffer);
+    assert(std::move(iter).base().base() == buffer);
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const cpp20_input_iterator<int*>&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), cpp20_input_iterator<int*>);
+  }
+
+  {
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+    assert(iter.base() == forward_iterator<int*>{buffer});
+    assert(std::move(iter).base() == forward_iterator<int*>{buffer});
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const forward_iterator<int*>&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), forward_iterator<int*>);
+  }
+
+  {
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    assert(iter.base() == contiguous_iterator<int*>{buffer});
+    assert(std::move(iter).base() == contiguous_iterator<int*>{buffer});
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const contiguous_iterator<int*>&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), contiguous_iterator<int*>);
+  }
+
+  {
+    std::counted_iterator iter(InputOrOutputArchetype{buffer}, 6);
+    assert(iter.base().ptr == buffer);
+    assert(std::move(iter).base().ptr == buffer);
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const InputOrOutputArchetype&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), InputOrOutputArchetype);
+  }
+
+  {
+    const std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(iter.base().base() == buffer);
+    assert(std::move(iter).base().base() == buffer);
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const cpp20_input_iterator<int*>&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), const cpp20_input_iterator<int*>&);
+  }
+
+  {
+    const std::counted_iterator iter(forward_iterator<int*>{buffer}, 7);
+    assert(iter.base() == forward_iterator<int*>{buffer});
+    assert(std::move(iter).base() == forward_iterator<int*>{buffer});
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const forward_iterator<int*>&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), const forward_iterator<int*>&);
+  }
+
+  {
+    const std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 6);
+    assert(iter.base() == contiguous_iterator<int*>{buffer});
+    assert(std::move(iter).base() == contiguous_iterator<int*>{buffer});
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const contiguous_iterator<int*>&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), const contiguous_iterator<int*>&);
+  }
+
+  {
+    const std::counted_iterator iter(InputOrOutputArchetype{buffer}, 6);
+    assert(iter.base().ptr == buffer);
+    assert(std::move(iter).base().ptr == buffer);
+
+    ASSERT_SAME_TYPE(decltype(iter.base()), const InputOrOutputArchetype&);
+    ASSERT_SAME_TYPE(decltype(std::move(iter).base()), const InputOrOutputArchetype&);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/compare.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<common_with<I> I2>
+//   friend constexpr bool operator==(
+//     const counted_iterator& x, const counted_iterator<I2>& y);
+// friend constexpr bool operator==(
+//   const counted_iterator& x, default_sentinel_t);
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// This iterator is common_with forward_iterator but NOT comparable with it.
+template <class It>
+class CommonWithForwardIter
+{
+    It it_;
+
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    constexpr It base() const {return it_;}
+
+    CommonWithForwardIter() = default;
+    explicit constexpr CommonWithForwardIter(It it) : it_(it) {}
+    constexpr CommonWithForwardIter(const forward_iterator<It>& it) : it_(it.base()) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr CommonWithForwardIter& operator++() {++it_; return *this;}
+    constexpr CommonWithForwardIter operator++(int)
+        {CommonWithForwardIter tmp(*this); ++(*this); return tmp;}
+};
+
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int *ptr;
+
+  constexpr int operator*() { return *ptr; }
+  constexpr void operator++(int) { ++ptr; }
+  constexpr InputOrOutputArchetype& operator++() { ++ptr; return *this; }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    {
+      std::counted_iterator iter1(forward_iterator<int*>(buffer), 8);
+      std::counted_iterator iter2(CommonWithForwardIter<int*>(buffer), 8);
+
+      assert(iter1 == iter2);
+      assert(iter2 == iter1);
+      ++iter1;
+      assert(iter1 != iter2);
+      assert(iter2 != iter1);
+    }
+  }
+
+  {
+    {
+      std::counted_iterator iter(cpp20_input_iterator<int*>(buffer), 8);
+
+      assert(iter != std::default_sentinel);
+      assert(std::default_sentinel == std::ranges::next(std::move(iter), 8));
+    }
+    {
+      std::counted_iterator iter(forward_iterator<int*>(buffer), 8);
+
+      assert(iter != std::default_sentinel);
+      assert(std::default_sentinel == std::ranges::next(iter, 8));
+    }
+    {
+      std::counted_iterator iter(random_access_iterator<int*>(buffer), 8);
+
+      assert(iter != std::default_sentinel);
+      assert(std::default_sentinel == std::ranges::next(iter, 8));
+    }
+    {
+      std::counted_iterator iter(InputOrOutputArchetype{buffer}, 8);
+
+      assert(iter != std::default_sentinel);
+      assert(std::default_sentinel == std::ranges::next(iter, 8));
+    }
+  }
+
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/count.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr iter_difference_t<I> count() const noexcept;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int *ptr;
+
+  constexpr int operator*() { return *ptr; }
+  constexpr void operator++(int) { ++ptr; }
+  constexpr InputOrOutputArchetype& operator++() { ++ptr; return *this; }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    for (unsigned i = 8; i != 0; --i, ++iter)
+      assert(iter.count() == i);
+
+    static_assert(noexcept(iter.count()));
+  }
+  {
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+    for (unsigned i = 8; i != 0; --i, ++iter)
+      assert(iter.count() == i);
+
+    static_assert(noexcept(iter.count()));
+  }
+  {
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    for (unsigned i = 8; i != 0; --i, ++iter)
+      assert(iter.count() == i);
+  }
+  {
+    std::counted_iterator iter(InputOrOutputArchetype{buffer + 2}, 6);
+    assert(iter.count() == 6);
+  }
+
+  // Const tests.
+  {
+    const std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(iter.count() == 8);
+  }
+  {
+    const std::counted_iterator iter(forward_iterator<int*>{buffer + 1}, 7);
+    assert(iter.count() == 7);
+  }
+  {
+    const std::counted_iterator iter(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(iter.count() == 6);
+  }
+  {
+    const std::counted_iterator iter(InputOrOutputArchetype{buffer + 2}, 6);
+    assert(iter.count() == 6);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/ctor.conv.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class I2>
+//   requires convertible_to<const I2&, I>
+//     constexpr counted_iterator(const counted_iterator<I2>& x);
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<class T>
+class ConvertibleTo
+{
+    int *it_;
+
+public:
+    typedef          std::input_iterator_tag                      iterator_category;
+    typedef int                                                   value_type;
+    typedef typename std::iterator_traits<int *>::difference_type difference_type;
+    typedef int *                                                 pointer;
+    typedef int &                                                 reference;
+
+    constexpr int *base() const {return it_;}
+
+    ConvertibleTo() = default;
+    explicit constexpr ConvertibleTo(int *it) : it_(it) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr ConvertibleTo& operator++() {++it_; return *this;}
+    constexpr ConvertibleTo operator++(int)
+        {ConvertibleTo tmp(*this); ++(*this); return tmp;}
+
+    constexpr operator T() const { return T(it_); }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( std::is_constructible_v<std::counted_iterator<forward_iterator<int*>>,
+                                           std::counted_iterator<forward_iterator<int*>>>);
+    static_assert(!std::is_constructible_v<std::counted_iterator<forward_iterator<int*>>,
+                                           std::counted_iterator<random_access_iterator<int*>>>);
+  }
+  {
+    std::counted_iterator iter1(ConvertibleTo<forward_iterator<int*>>{buffer}, 8);
+    std::counted_iterator<forward_iterator<int*>> iter2(iter1);
+    assert(iter2.base() == forward_iterator<int*>{buffer});
+    assert(iter2.count() == 8);
+  }
+  {
+    const std::counted_iterator iter1(ConvertibleTo<forward_iterator<int*>>{buffer}, 8);
+    const std::counted_iterator<forward_iterator<int*>> iter2(iter1);
+    assert(iter2.base() == forward_iterator<int*>{buffer});
+    assert(iter2.count() == 8);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr counted_iterator() requires default_initializable<I> = default;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+constexpr bool test() {
+  static_assert( std::default_initializable<std::counted_iterator<cpp17_input_iterator<int*>>>);
+  static_assert(!std::default_initializable<std::counted_iterator<cpp20_input_iterator<int*>>>);
+
+  std::counted_iterator<cpp17_input_iterator<int*>> iter;
+  assert(iter.base() == cpp17_input_iterator<int*>());
+  assert(iter.count() == 0);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/ctor.iter.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr counted_iterator() requires default_initializable<I> = default;
+// constexpr counted_iterator(I x, iter_difference_t<I> n);
+// template<class I2>
+//   requires convertible_to<const I2&, I>
+//     constexpr counted_iterator(const counted_iterator<I2>& x);
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int *ptr;
+
+  constexpr int operator*() { return *ptr; }
+  constexpr void operator++(int) { ++ptr; }
+  constexpr InputOrOutputArchetype& operator++() { ++ptr; return *this; }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(iter.base().base() == buffer);
+    assert(iter.count() == 8);
+  }
+
+  {
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+    assert(iter.base() == forward_iterator<int*>{buffer});
+    assert(iter.count() == 8);
+  }
+
+  {
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    assert(iter.base() == contiguous_iterator<int*>{buffer});
+    assert(iter.count() == 8);
+  }
+
+  {
+    std::counted_iterator iter(InputOrOutputArchetype{buffer}, 8);
+    assert(iter.base().ptr == buffer);
+    assert(iter.count() == 8);
+  }
+
+  {
+    const std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(iter.base().base() == buffer);
+    assert(iter.count() == 8);
+  }
+
+  {
+    const std::counted_iterator iter(forward_iterator<int*>{buffer}, 7);
+    assert(iter.base() == forward_iterator<int*>{buffer});
+    assert(iter.count() == 7);
+  }
+
+  {
+    const std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 6);
+    assert(iter.base() == contiguous_iterator<int*>{buffer});
+    assert(iter.count() == 6);
+  }
+
+  {
+    const std::counted_iterator iter(InputOrOutputArchetype{buffer}, 8);
+    assert(iter.base().ptr == buffer);
+    assert(iter.count() == 8);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/decrement.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr counted_iterator& operator--()
+//  requires bidirectional_iterator<I>;
+// constexpr counted_iterator operator--(int)
+//  requires bidirectional_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<class Iter>
+concept MinusEnabled = requires(Iter& iter) {
+  iter--;
+  --iter;
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    using Counted = std::counted_iterator<bidirectional_iterator<int*>>;
+    std::counted_iterator iter(bidirectional_iterator<int*>{buffer + 2}, 6);
+    assert(iter-- == Counted(bidirectional_iterator<int*>{buffer + 2}, 6));
+    assert(--iter == Counted(bidirectional_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter--), Counted);
+    ASSERT_SAME_TYPE(decltype(--iter), Counted&);
+  }
+  {
+    using Counted = std::counted_iterator<random_access_iterator<int*>>;
+    Counted iter(random_access_iterator<int*>{buffer + 2}, 6);
+    assert(iter-- == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+    assert(--iter == Counted(random_access_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter--), Counted);
+    ASSERT_SAME_TYPE(decltype(--iter), Counted&);
+  }
+  {
+    using Counted = std::counted_iterator<contiguous_iterator<int*>>;
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(iter-- == Counted(contiguous_iterator<int*>{buffer + 2}, 6));
+    assert(--iter == Counted(contiguous_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter--), Counted);
+    ASSERT_SAME_TYPE(decltype(--iter), Counted&);
+  }
+
+  {
+    static_assert( MinusEnabled<std::counted_iterator<contiguous_iterator<int*>>>);
+    static_assert(!MinusEnabled<const std::counted_iterator<contiguous_iterator<int*>>>);
+    static_assert(!MinusEnabled<std::counted_iterator<forward_iterator<int*>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/deref.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr decltype(auto) operator*();
+// constexpr decltype(auto) operator*() const
+//   requires dereferenceable<const I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int *ptr;
+
+  constexpr int operator*() const { return *ptr; }
+  constexpr void operator++(int) { ++ptr; }
+  constexpr InputOrOutputArchetype& operator++() { ++ptr; return *this; }
+};
+
+struct NonConstDeref {
+  using difference_type = int;
+
+  int *ptr;
+
+  constexpr int operator*() { return *ptr; }
+  constexpr void operator++(int) { ++ptr; }
+  constexpr NonConstDeref& operator++() { ++ptr; return *this; }
+};
+
+template<class T>
+concept IsDereferenceable = requires(T& i) {
+  *i;
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( IsDereferenceable<std::counted_iterator<InputOrOutputArchetype>>);
+    static_assert( IsDereferenceable<const std::counted_iterator<InputOrOutputArchetype>>);
+    static_assert( IsDereferenceable<std::counted_iterator<NonConstDeref>>);
+    static_assert(!IsDereferenceable<const std::counted_iterator<NonConstDeref>>);
+  }
+
+  {
+    std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    for (int i = 1; i < 9; ++i, ++iter)
+      assert(*iter == i);
+  }
+
+  {
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+    for (int i = 1; i < 9; ++i, ++iter)
+      assert(*iter == i);
+  }
+
+  {
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    for (int i = 1; i < 9; ++i, ++iter)
+      assert(*iter == i);
+  }
+
+  {
+    std::counted_iterator iter(InputOrOutputArchetype{buffer}, 8);
+    for (int i = 1; i < 9; ++i, ++iter)
+      assert(*iter == i);
+  }
+
+  {
+    const std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(*iter == 1);
+  }
+
+  {
+    const std::counted_iterator iter(forward_iterator<int*>{buffer + 1}, 7);
+    assert(*iter == 2);
+  }
+
+  {
+    const std::counted_iterator iter(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(*iter == 3);
+  }
+
+  {
+    const std::counted_iterator iter(InputOrOutputArchetype{buffer + 2}, 6);
+    assert(*iter == 3);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/increment.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr counted_iterator& operator++();
+// decltype(auto) operator++(int);
+// constexpr counted_iterator operator++(int)
+//   requires forward_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+template <class It>
+class ThrowsOnInc
+{
+    It it_;
+
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    constexpr It base() const {return it_;}
+
+    ThrowsOnInc() = default;
+    explicit constexpr ThrowsOnInc(It it) : it_(it) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr ThrowsOnInc& operator++() {throw 42;}
+    constexpr ThrowsOnInc operator++(int) {throw 42;}
+};
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int *ptr;
+
+  constexpr int operator*() const { return *ptr; }
+  constexpr void operator++(int) { ++ptr; }
+  constexpr InputOrOutputArchetype& operator++() { ++ptr; return *this; }
+};
+
+template<class Iter>
+concept PlusEnabled = requires(Iter& iter) {
+  iter++;
+  ++iter;
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    using Counted = std::counted_iterator<forward_iterator<int*>>;
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+
+    assert(iter++ == Counted(forward_iterator<int*>{buffer}, 8));
+    assert(++iter == Counted(forward_iterator<int*>{buffer + 2}, 6));
+
+    ASSERT_SAME_TYPE(decltype(iter++), Counted);
+    ASSERT_SAME_TYPE(decltype(++iter), Counted&);
+  }
+  {
+    using Counted = std::counted_iterator<random_access_iterator<int*>>;
+    std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+
+    assert(iter++ == Counted(random_access_iterator<int*>{buffer}, 8));
+    assert(++iter == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+
+    ASSERT_SAME_TYPE(decltype(iter++), Counted);
+    ASSERT_SAME_TYPE(decltype(++iter), Counted&);
+  }
+
+  {
+    static_assert( PlusEnabled<      std::counted_iterator<random_access_iterator<int*>>>);
+    static_assert(!PlusEnabled<const std::counted_iterator<random_access_iterator<int*>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    using Counted = std::counted_iterator<InputOrOutputArchetype>;
+    std::counted_iterator iter(InputOrOutputArchetype{buffer}, 8);
+
+    iter++;
+    assert((++iter).base().ptr == buffer + 2);
+
+    ASSERT_SAME_TYPE(decltype(iter++), void);
+    ASSERT_SAME_TYPE(decltype(++iter), Counted&);
+  }
+  {
+    using Counted = std::counted_iterator<cpp20_input_iterator<int*>>;
+    std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+
+    iter++;
+    assert(++iter == Counted(cpp20_input_iterator<int*>{buffer + 2}, 6));
+
+    ASSERT_SAME_TYPE(decltype(iter++), void);
+    ASSERT_SAME_TYPE(decltype(++iter), Counted&);
+  }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    using Counted = std::counted_iterator<ThrowsOnInc<int*>>;
+    std::counted_iterator iter(ThrowsOnInc<int*>{buffer}, 8);
+    try {
+      (void)iter++;
+      assert(false);
+    } catch (int x) {
+      assert(x == 42);
+      assert(iter.count() == 8);
+    }
+
+    ASSERT_SAME_TYPE(decltype(iter++), ThrowsOnInc<int*>);
+    ASSERT_SAME_TYPE(decltype(++iter), Counted&);
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/iter_move.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// friend constexpr iter_rvalue_reference_t<I>
+//   iter_move(const counted_iterator& i)
+//     noexcept(noexcept(ranges::iter_move(i.current)))
+//     requires input_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<bool IsNoexcept>
+class HasNoexceptIterMove
+{
+  int *it_;
+
+public:
+  typedef          std::input_iterator_tag                      iterator_category;
+  typedef int                                                   value_type;
+  typedef typename std::iterator_traits<int *>::difference_type difference_type;
+  typedef int *                                                 pointer;
+  typedef int &                                                 reference;
+
+  constexpr int *base() const {return it_;}
+
+  HasNoexceptIterMove() = default;
+  explicit constexpr HasNoexceptIterMove(int *it) : it_(it) {}
+
+  constexpr reference operator*() const noexcept(IsNoexcept) { return *it_; }
+
+  constexpr HasNoexceptIterMove& operator++() {++it_; return *this;}
+  constexpr HasNoexceptIterMove operator++(int)
+      {HasNoexceptIterMove tmp(*this); ++(*this); return tmp;}
+};
+
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+
+  // Test noexceptness.
+  {
+    static_assert( noexcept(std::ranges::iter_move(std::declval<std::counted_iterator<HasNoexceptIterMove<true>>>())));
+    static_assert(!noexcept(std::ranges::iter_move(std::declval<std::counted_iterator<HasNoexceptIterMove<false>>>())));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/iter_swap.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<indirectly_swappable<I> I2>
+//   friend constexpr void
+//     iter_swap(const counted_iterator& x, const counted_iterator<I2>& y)
+//       noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<bool IsNoexcept>
+class HasNoexceptIterSwap
+{
+  int *it_;
+
+public:
+  typedef          std::input_iterator_tag                      iterator_category;
+  typedef int                                                   value_type;
+  typedef typename std::iterator_traits<int *>::difference_type difference_type;
+  typedef int *                                                 pointer;
+  typedef int &                                                 reference;
+
+  constexpr int *base() const {return it_;}
+
+  HasNoexceptIterSwap() = default;
+  explicit constexpr HasNoexceptIterSwap(int *it) : it_(it) {}
+
+  constexpr reference operator*() const {return *it_;}
+
+  constexpr HasNoexceptIterSwap& operator++() {++it_; return *this;}
+  constexpr HasNoexceptIterSwap operator++(int)
+      {HasNoexceptIterSwap tmp(*this); ++(*this); return tmp;}
+
+  friend void iter_swap(const HasNoexceptIterSwap&, const HasNoexceptIterSwap&) noexcept(IsNoexcept);
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    auto commonIter2 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    auto commonIter2 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    auto commonIter2 = std::counted_iterator<decltype(iter1)>(iter1, 8);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+
+  // Test noexceptness.
+  {
+    static_assert( noexcept(std::ranges::iter_swap(
+      std::declval<std::counted_iterator<HasNoexceptIterSwap<true>>&>(),
+      std::declval<std::counted_iterator<HasNoexceptIterSwap<true>>&>()
+    )));
+    static_assert(!noexcept(std::ranges::iter_swap(
+      std::declval<std::counted_iterator<HasNoexceptIterSwap<false>>&>(),
+      std::declval<std::counted_iterator<HasNoexceptIterSwap<false>>&>()
+    )));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/iterator_traits.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<input_iterator I>
+//   requires same_as<ITER_TRAITS(I), iterator_traits<I>>   // see [iterator.concepts.general]
+// struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
+//   using pointer = conditional_t<contiguous_iterator<I>,
+//                                 add_pointer_t<iter_reference_t<I>>, void>;
+// };
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+void test() {
+  {
+    using Iter = cpp17_input_iterator<int*>;
+    using CommonIter = std::counted_iterator<Iter>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, void>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = forward_iterator<int*>;
+    using CommonIter = std::counted_iterator<Iter>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, void>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = random_access_iterator<int*>;
+    using CommonIter = std::counted_iterator<Iter>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, void>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = contiguous_iterator<int*>;
+    using CommonIter = std::counted_iterator<Iter>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_category, std::contiguous_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, int*>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+
+  // Testing iterator conformance.
+  {
+    static_assert(std::input_iterator<std::counted_iterator<cpp17_input_iterator<int*>>>);
+    static_assert(std::forward_iterator<std::counted_iterator<forward_iterator<int*>>>);
+    static_assert(std::bidirectional_iterator<std::counted_iterator<random_access_iterator<int*>>>);
+    static_assert(std::bidirectional_iterator<std::counted_iterator<contiguous_iterator<int*>>>);
+    static_assert(!std::random_access_iterator<std::counted_iterator<random_access_iterator<int*>>>);
+    static_assert(!std::random_access_iterator<std::counted_iterator<contiguous_iterator<int*>>>);
+
+    using Iter = std::counted_iterator<forward_iterator<int*>>;
+    static_assert(std::indirectly_writable<Iter, int>);
+    static_assert(std::indirectly_swappable<Iter, Iter>);
+  }
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/member_types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// iterator_type, value_type, difference_type, iterator_concept, iterator_category
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// No value_type.
+struct InputOrOutputArchetype {
+  using difference_type = int;
+
+  int operator*();
+  void operator++(int);
+  InputOrOutputArchetype& operator++();
+};
+
+template<class T>
+concept HasValueType = requires { typename T::value_type; };
+
+template<class T>
+concept HasIteratorConcept = requires { typename T::iterator_concept; };
+
+template<class T>
+concept HasIteratorCategory = requires { typename T::iterator_category; };
+
+void test() {
+  {
+    using Iter = std::counted_iterator<InputOrOutputArchetype>;
+    static_assert(std::same_as<Iter::iterator_type, InputOrOutputArchetype>);
+    static_assert(!HasValueType<Iter>);
+    static_assert(std::same_as<Iter::difference_type, int>);
+    static_assert(!HasIteratorConcept<Iter>);
+    static_assert(!HasIteratorCategory<Iter>);
+  }
+  {
+    using Iter = std::counted_iterator<cpp20_input_iterator<int*>>;
+    static_assert(std::same_as<Iter::iterator_type, cpp20_input_iterator<int*>>);
+    static_assert(std::same_as<Iter::value_type, int>);
+    static_assert(std::same_as<Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<Iter::iterator_concept, std::input_iterator_tag>);
+    static_assert(!HasIteratorCategory<Iter>);
+  }
+  {
+    using Iter = std::counted_iterator<random_access_iterator<int*>>;
+    static_assert(std::same_as<Iter::iterator_type, random_access_iterator<int*>>);
+    static_assert(std::same_as<Iter::value_type, int>);
+    static_assert(std::same_as<Iter::difference_type, std::ptrdiff_t>);
+    static_assert(!HasIteratorConcept<Iter>);
+    static_assert(std::same_as<Iter::iterator_category, std::random_access_iterator_tag>);
+  }
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/minus.default_sentinel.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// friend constexpr iter_difference_t<I> operator-(
+//   const counted_iterator& x, default_sentinel_t);
+// friend constexpr iter_difference_t<I> operator-(
+//   default_sentinel_t, const counted_iterator& y);
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+    assert(iter - std::default_sentinel == -8);
+    assert(std::default_sentinel - iter == 8);
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter - std::default_sentinel), std::iter_difference_t<int*>);
+    ASSERT_SAME_TYPE(decltype(std::default_sentinel - iter), std::iter_difference_t<int*>);
+  }
+  {
+    const std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+    assert(iter - std::default_sentinel == -8);
+    assert(std::default_sentinel - iter == 8);
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter - std::default_sentinel), std::iter_difference_t<int*>);
+    ASSERT_SAME_TYPE(decltype(std::default_sentinel - iter), std::iter_difference_t<int*>);
+  }
+  {
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+    assert(iter - std::default_sentinel == -8);
+    assert(std::default_sentinel - iter == 8);
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter - std::default_sentinel), std::iter_difference_t<int*>);
+    ASSERT_SAME_TYPE(decltype(std::default_sentinel - iter), std::iter_difference_t<int*>);
+  }
+  {
+    const std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+    assert(iter - std::default_sentinel == -8);
+    assert(std::default_sentinel - iter == 8);
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter - std::default_sentinel), std::iter_difference_t<int*>);
+    ASSERT_SAME_TYPE(decltype(std::default_sentinel - iter), std::iter_difference_t<int*>);
+  }
+  {
+    std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(iter - std::default_sentinel == -8);
+    assert(std::default_sentinel - iter == 8);
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter - std::default_sentinel), std::iter_difference_t<int*>);
+    ASSERT_SAME_TYPE(decltype(std::default_sentinel - iter), std::iter_difference_t<int*>);
+  }
+  {
+    const std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+    assert(iter - std::default_sentinel == -8);
+    assert(std::default_sentinel - iter == 8);
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter - std::default_sentinel), std::iter_difference_t<int*>);
+    ASSERT_SAME_TYPE(decltype(std::default_sentinel - iter), std::iter_difference_t<int*>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/minus.eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr counted_iterator& operator-=(iter_difference_t<I> n)
+//   requires random_access_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<class Iter>
+concept MinusEqEnabled = requires(Iter& iter) {
+  iter -= 1;
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    using Counted = std::counted_iterator<random_access_iterator<int*>>;
+    Counted iter(random_access_iterator<int*>{buffer + 2}, 6);
+    assert((iter -= 2) == Counted(random_access_iterator<int*>{buffer}, 8));
+    assert((iter -= 0) == Counted(random_access_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter -= 2), Counted&);
+  }
+  {
+    using Counted = std::counted_iterator<contiguous_iterator<int*>>;
+    Counted iter(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert((iter -= 2) == Counted(contiguous_iterator<int*>{buffer}, 8));
+    assert((iter -= 0) == Counted(contiguous_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter -= 2), Counted&);
+  }
+  {
+    static_assert( MinusEqEnabled<      std::counted_iterator<random_access_iterator<int*>>>);
+    static_assert(!MinusEqEnabled<const std::counted_iterator<random_access_iterator<int*>>>);
+  }
+
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/minus.iter.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<common_with<I> I2>
+//   friend constexpr iter_difference_t<I2> operator-(
+//     const counted_iterator& x, const counted_iterator<I2>& y);
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// This iterator is common_with forward_iterator but NOT comparable with it.
+template <class It>
+class CommonWithForwardIter
+{
+    It it_;
+
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    constexpr It base() const {return it_;}
+
+    CommonWithForwardIter() = default;
+    explicit constexpr CommonWithForwardIter(It it) : it_(it) {}
+    constexpr CommonWithForwardIter(const forward_iterator<It>& it) : it_(it.base()) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr CommonWithForwardIter& operator++() {++it_; return *this;}
+    constexpr CommonWithForwardIter operator++(int)
+        {CommonWithForwardIter tmp(*this); ++(*this); return tmp;}
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::counted_iterator iter1(random_access_iterator<int*>{buffer}, 8);
+    std::counted_iterator iter2(random_access_iterator<int*>{buffer + 4}, 4);
+    assert(iter1 - iter2 == -4);
+    assert(iter2 - iter1 == 4);
+    assert(iter1.count() == 8);
+    assert(iter2.count() == 4);
+
+    ASSERT_SAME_TYPE(decltype(iter1 - iter2), std::iter_difference_t<int*>);
+  }
+  {
+    const std::counted_iterator iter1(random_access_iterator<int*>{buffer}, 8);
+    const std::counted_iterator iter2(random_access_iterator<int*>{buffer + 4}, 4);
+    assert(iter1 - iter2 == -4);
+    assert(iter2 - iter1 == 4);
+    assert(iter1.count() == 8);
+    assert(iter2.count() == 4);
+
+    ASSERT_SAME_TYPE(decltype(iter1 - iter2), std::iter_difference_t<int*>);
+  }
+  {
+    std::counted_iterator iter1(contiguous_iterator<int*>{buffer}, 8);
+    std::counted_iterator iter2(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(iter1 - iter2 == -2);
+    assert(iter2 - iter1 == 2);
+    assert(iter1.count() == 8);
+    assert(iter2.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 - iter2), std::iter_difference_t<int*>);
+  }
+  {
+    const std::counted_iterator iter1(contiguous_iterator<int*>{buffer}, 8);
+    const std::counted_iterator iter2(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(iter1 - iter2 == -2);
+    assert(iter2 - iter1 == 2);
+    assert(iter1.count() == 8);
+    assert(iter2.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 - iter2), std::iter_difference_t<int*>);
+  }
+  // The minus operator works even if Iter is not a random_access_iterator because
+  // counted_iterator is able to implement it by subtracting the counts rather than
+  // the underlying iterators.
+  {
+    std::counted_iterator iter1(CommonWithForwardIter<int*>{buffer}, 8);
+    std::counted_iterator iter2(forward_iterator<int*>{buffer + 2}, 6);
+    assert(iter1 - iter2 == -2);
+    assert(iter2 - iter1 == 2);
+    assert(iter1.count() == 8);
+    assert(iter2.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 - iter2), std::iter_difference_t<int*>);
+  }
+  {
+    const std::counted_iterator iter1(CommonWithForwardIter<int*>{buffer}, 8);
+    const std::counted_iterator iter2(forward_iterator<int*>{buffer + 2}, 6);
+    assert(iter1 - iter2 == -2);
+    assert(iter2 - iter1 == 2);
+    assert(iter1.count() == 8);
+    assert(iter2.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter1 - iter2), std::iter_difference_t<int*>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/minus.size.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr counted_iterator operator-(iter_difference_t<I> n) const
+//   requires random_access_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<class Iter>
+concept MinusEnabled = requires(Iter& iter) {
+  iter - 1;
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    using Counted = std::counted_iterator<random_access_iterator<int*>>;
+    Counted iter(random_access_iterator<int*>{buffer + 2}, 6);
+    assert(iter - 2 == Counted(random_access_iterator<int*>{buffer}, 8));
+    assert(iter - 0 == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+    assert(iter.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter - 2), Counted);
+  }
+  {
+    using Counted = std::counted_iterator<random_access_iterator<int*>>;
+    const Counted iter(random_access_iterator<int*>{buffer + 2}, 6);
+    assert(iter - 2 == Counted(random_access_iterator<int*>{buffer}, 8));
+    assert(iter - 0 == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+    assert(iter.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter - 2), Counted);
+  }
+  {
+    using Counted = std::counted_iterator<contiguous_iterator<int*>>;
+    Counted iter(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(iter - 2 == Counted(contiguous_iterator<int*>{buffer}, 8));
+    assert(iter - 0 == Counted(contiguous_iterator<int*>{buffer + 2}, 6));
+    assert(iter.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter - 2), Counted);
+  }
+  {
+    using Counted = std::counted_iterator<contiguous_iterator<int*>>;
+    const Counted iter(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(iter - 2 == Counted(contiguous_iterator<int*>{buffer}, 8));
+    assert(iter - 0 == Counted(contiguous_iterator<int*>{buffer + 2}, 6));
+    assert(iter.count() == 6);
+
+    ASSERT_SAME_TYPE(decltype(iter - 2), Counted);
+  }
+
+  {
+    static_assert( MinusEnabled<std::counted_iterator<random_access_iterator<int*>>>);
+    static_assert(!MinusEnabled<std::counted_iterator<bidirectional_iterator<int*>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/plus.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr counted_iterator operator+(iter_difference_t<I> n) const
+//     requires random_access_iterator<I>;
+// friend constexpr counted_iterator operator+(
+//   iter_difference_t<I> n, const counted_iterator& x)
+//     requires random_access_iterator<I>;
+// constexpr counted_iterator& operator+=(iter_difference_t<I> n)
+//     requires random_access_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<class Iter>
+concept PlusEnabled = requires(Iter& iter) {
+  iter + 1;
+};
+
+template<class Iter>
+concept PlusEqEnabled = requires(Iter& iter) {
+  iter += 1;
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    {
+      using Counted = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(iter + 2 == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+      assert(iter + 0 == Counted(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), Counted);
+    }
+    {
+      using Counted = const std::counted_iterator<random_access_iterator<int*>>;
+      const std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(iter + 8 == Counted(random_access_iterator<int*>{buffer + 8}, 0));
+      assert(iter + 0 == Counted(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), std::remove_const_t<Counted>);
+    }
+  }
+
+  {
+    {
+      using Counted = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(2 + iter == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+      assert(0 + iter == Counted(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), Counted);
+    }
+    {
+      using Counted = const std::counted_iterator<random_access_iterator<int*>>;
+      const std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(8 + iter == Counted(random_access_iterator<int*>{buffer + 8}, 0));
+      assert(0 + iter == Counted(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), std::remove_const_t<Counted>);
+    }
+  }
+
+  {
+    {
+      using Counted = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert((iter += 2) == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+      assert((iter += 0) == Counted(random_access_iterator<int*>{buffer + 2}, 6));
+
+      ASSERT_SAME_TYPE(decltype(iter += 2), Counted&);
+    }
+    {
+      using Counted = std::counted_iterator<contiguous_iterator<int*>>;
+      std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+      assert((iter += 8) == Counted(contiguous_iterator<int*>{buffer + 8}, 0));
+      assert((iter += 0) == Counted(contiguous_iterator<int*>{buffer + 8}, 0));
+
+      ASSERT_SAME_TYPE(decltype(iter += 2), Counted&);
+    }
+    {
+      static_assert( PlusEnabled<std::counted_iterator<random_access_iterator<int*>>>);
+      static_assert(!PlusEnabled<std::counted_iterator<bidirectional_iterator<int*>>>);
+
+      static_assert( PlusEqEnabled<      std::counted_iterator<random_access_iterator<int*>>>);
+      static_assert(!PlusEqEnabled<const std::counted_iterator<random_access_iterator<int*>>>);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/subscript.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr decltype(auto) operator[](iter_difference_t<I> n) const
+//   requires random_access_iterator<I>;
+
+#include <iterator>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template<class Iter>
+concept SubscriptEnabled = requires(Iter& iter) {
+  iter[1];
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+    for (int i = 1; i < 9; ++i)
+      assert(iter[i - 1] == i);
+  }
+  {
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    for (int i = 1; i < 9; ++i)
+      assert(iter[i - 1] == i);
+  }
+
+  {
+    const std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+    assert(iter[0] == 1);
+  }
+  {
+    const std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    assert(iter[7] == 8);
+  }
+
+  {
+      static_assert( SubscriptEnabled<std::counted_iterator<random_access_iterator<int*>>>);
+      static_assert(!SubscriptEnabled<std::counted_iterator<bidirectional_iterator<int*>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr V base() const& requires copy_constructible<V>;
+// constexpr V base() &&;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+constexpr bool hasLValueQualifiedBase(auto&& view) {
+    return requires { view.base(); };
+}
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 0);
+    assert(tv.base().ptr_ == buffer);
+    assert(std::move(tv).base().ptr_ == buffer);
+
+    ASSERT_SAME_TYPE(decltype(tv.base()), CopyableView);
+    ASSERT_SAME_TYPE(decltype(std::move(tv).base()), CopyableView);
+    static_assert(hasLValueQualifiedBase(tv));
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 1);
+    assert(std::move(tv).base().ptr_ == buffer);
+
+    ASSERT_SAME_TYPE(decltype(std::move(tv).base()), ContiguousView);
+    static_assert(!hasLValueQualifiedBase(tv));
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 2);
+    assert(tv.base().ptr_ == buffer);
+    assert(std::move(tv).base().ptr_ == buffer);
+
+    ASSERT_SAME_TYPE(decltype(tv.base()), CopyableView);
+    ASSERT_SAME_TYPE(decltype(std::move(tv).base()), CopyableView);
+    static_assert(hasLValueQualifiedBase(tv));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto begin() requires (!simple-view<V>);
+// constexpr auto begin() const requires range<const V>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+#include "types.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 4);
+    assert(tv.begin() == begin(SizedRandomAccessView(buffer)));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), RandomAccessIter);
+  }
+
+  {
+    const std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 4);
+    assert(tv.begin() == begin(SizedRandomAccessView(buffer)));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), RandomAccessIter);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<ForwardIter>(ForwardIter(buffer), 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<ForwardIter>);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<ForwardIter>(ForwardIter(buffer), 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<ForwardIter>);
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  {
+    const std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.take/borrowing.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: gcc-10
+
+// template<class T>
+//   inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
+
+#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&);
+};
+
+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&);
+};
+
+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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class R>
+//   take_view(R&&, range_difference_t<R>) -> take_view<views::all_t<R>>;
+
+#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&);
+};
+
+struct Range {
+  friend int* begin(Range&);
+  friend int* begin(Range const&);
+  friend sentinel_wrapper<int*> end(Range&);
+  friend sentinel_wrapper<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&);
+};
+
+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::take_view(v, 0)),
+        std::ranges::take_view<View>
+    >);
+    static_assert(std::same_as<
+        decltype(std::ranges::take_view(r, 0)),
+        std::ranges::take_view<std::ranges::ref_view<Range>>
+    >);
+    // 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>>
+    >);
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// take_view() requires default_initializable<V> = default;
+// constexpr take_view(V base, range_difference_t<V> count);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+template<bool IsDefaultCtorable>
+struct DefaultConstructible : std::ranges::view_base {
+  DefaultConstructible() requires IsDefaultCtorable = default;
+  DefaultConstructible(int*);
+  int* begin();
+  sentinel_wrapper<int*> end();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( std::default_initializable<DefaultConstructible<true>>);
+    static_assert(!std::default_initializable<DefaultConstructible<false>>);
+  }
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 0);
+    assert(tv.base().ptr_ == buffer);
+    assert(tv.begin() == tv.end()); // Checking we have correct size.
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 1);
+    assert(std::move(tv).base().ptr_ == buffer);
+    assert(std::ranges::next(tv.begin(), 1) == tv.end()); // Checking we have correct size.
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 2);
+    assert(tv.base().ptr_ == buffer);
+    assert(std::ranges::next(tv.begin(), 2) == tv.end()); // Checking we have correct size.
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto end() requires (!simple-view<V>)
+// constexpr auto end() const requires range<const V>
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+#include "types.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 0);
+    assert(tv.end() == std::ranges::next(tv.begin(), 0));
+    ASSERT_SAME_TYPE(decltype(tv.end()), RandomAccessIter);
+  }
+
+  {
+    const std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 1);
+    assert(tv.end() == std::ranges::next(tv.begin(), 1));
+    ASSERT_SAME_TYPE(decltype(tv.end()), RandomAccessIter);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 2);
+    assert(tv.end() == std::ranges::next(tv.begin(), 2));
+    ASSERT_SAME_TYPE(decltype(tv.end()), std::default_sentinel_t);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 3);
+    assert(tv.end() == std::ranges::next(tv.begin(), 3));
+    ASSERT_SAME_TYPE(decltype(tv.end()), std::default_sentinel_t);
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.end() == std::ranges::next(tv.begin(), 4));
+
+    // The <sentinel> type.
+    static_assert(!std::same_as<decltype(tv.end()), std::default_sentinel_t>);
+    static_assert(!std::same_as<decltype(tv.end()), int*>);
+  }
+
+  {
+    const std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 5);
+    assert(tv.end() == std::ranges::next(tv.begin(), 5));
+  }
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 6);
+    assert(tv.end() == std::ranges::next(tv.begin(), 6));
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 7);
+    assert(tv.end() == std::ranges::next(tv.begin(), 7));
+  }
+
+  // Just to cover the case where count == 8.
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 8);
+    assert(tv.end() == std::ranges::next(tv.begin(), 8));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// sentinel() = default;
+// constexpr explicit sentinel(sentinel_t<Base> end);
+// constexpr sentinel(sentinel<!Const> s)
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.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<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.end().base().base() == sw.base());
+    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// sentinel() = default;
+// constexpr explicit sentinel(sentinel_t<Base> end);
+// constexpr sentinel(sentinel<!Const> s)
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    // Test the default ctor.
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(decltype(tv.end()){} == std::ranges::next(tv.begin(), 4));
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> nonConst(ContiguousView{buffer}, 5);
+    const std::ranges::take_view<ContiguousView> tvConst(ContiguousView{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));
+  }
+
+  {
+    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());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// sentinel() = default;
+// constexpr explicit sentinel(sentinel_t<Base> end);
+// constexpr sentinel(sentinel<!Const> s)
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    {
+      const std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+      assert(tv.end() == std::ranges::next(tv.begin(), 4));
+      assert(std::ranges::next(tv.begin(), 4) == tv.end());
+    }
+
+    {
+      std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+      assert(tv.end() == std::ranges::next(tv.begin(), 4));
+      assert(std::ranges::next(tv.begin(), 4) == tv.end());
+    }
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tvNonConst(ContiguousView{buffer}, 4);
+    const std::ranges::take_view<ContiguousView> tvConst(ContiguousView{buffer}, 4);
+    assert(tvNonConst.end() == std::ranges::next(tvConst.begin(), 4));
+    assert(std::ranges::next(tvConst.begin(), 4) == tvNonConst.end());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto size() requires sized_range<V>
+// constexpr auto size() const requires sized_range<const V>
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+#include "types.h"
+
+template<class T>
+concept SizeEnabled = requires(const std::ranges::take_view<T>& tv) {
+  tv.size();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( SizeEnabled<SizedRandomAccessView>);
+    static_assert(!SizeEnabled<CopyableView>);
+  }
+
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 0);
+    assert(tv.size() == 0);
+  }
+
+  {
+    const std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 2);
+    assert(tv.size() == 2);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 4);
+    assert(tv.size() == 4);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 6);
+    assert(tv.size() == 6);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 8);
+    assert(tv.size() == 8);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 10);
+    assert(tv.size() == 8);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+using ForwardIter = forward_iterator<int*>;
+struct SizedForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedForwardView(int* ptr) : ptr_(ptr) {}
+  constexpr friend ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.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();
+}
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct SizedRandomAccessView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView const& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.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();
+}
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H

libcxx/test/support/test_iterators.h

 // clang-format off
 
 template <class I>
 struct cpp20_input_iterator {
   using value_type = std::iter_value_t<I>;
   using difference_type = std::iter_difference_t<I>;
   using iterator_concept = std::input_iterator_tag;
 
-  cpp20_input_iterator() = default;
+  cpp20_input_iterator() = delete;
 
   cpp20_input_iterator(cpp20_input_iterator&&) = default;
   cpp20_input_iterator& operator=(cpp20_input_iterator&&) = default;
 
   cpp20_input_iterator(cpp20_input_iterator const&) = delete;
   cpp20_input_iterator& operator=(cpp20_input_iterator const&) = delete;
 
   explicit constexpr cpp20_input_iterator(I base) : base_(std::move(base)) {}

libcxx/test/support/test_range.h

 #ifdef _LIBCPP_HAS_NO_RANGES
 #error "test/suppoort/test_range.h" can only be included in builds supporting ranges
 #endif
 
 struct sentinel {
   bool operator==(std::input_or_output_iterator auto const&) const;
 };
 
-// clang-format off
 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;
 };

 
 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();
 };
 
-// clang-format on
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  ContiguousView(ContiguousView&&) = default;
+  ContiguousView& operator=(ContiguousView&&) = default;
+
+  constexpr int* begin() {return ptr_;}
+  constexpr int* begin() const {return ptr_;}
+  constexpr sentinel_wrapper<int*> end() {return sentinel_wrapper<int*>{ptr_ + 8};}
+  constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};}
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+
+  constexpr int* begin() {return ptr_;}
+  constexpr int* begin() const {return ptr_;}
+  constexpr sentinel_wrapper<int*> end() {return sentinel_wrapper<int*>{ptr_ + 8};}
+  constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};}
+};
 
 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H