[libcxx][ranges] Add `counted_iterator`.

[zoecarver]

Remove completed todo.

[zoecarver]

Rebase.

[zoecarver]

Rebase.

[Mordante]

libcxx/include/CMakeLists.txt

137

Did you run libcxx/utils/generate_private_header_tests.py?

libcxx/include/__iterator/counted_iterator.h

40

Please add _LIBCPP_TEMPLATE_VIS here and other structs.

74

These two are exposition only private members. Is there a reason why you made them public?

79

Please add _LIBCPP_HIDE_FROM_ABI here and other functions.

205

How do you feel about adding _LIBCPP_ASSERTS to validate the precondtions?

221

Can you add a TODO/FIXME to remind to implement this function?

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

17

I miss tests to validate the proper noexcept status.

[zoecarver]

libcxx/include/__iterator/counted_iterator.h

205

I feel good about that :) done.

[zoecarver]

Apply review comments. Thanks Mark!

[ldionne]

libcxx/include/__iterator/counted_iterator.h

43–46

And then you can remove the named concept above.

54

Ditto.

62

This should be constrained on indirectly_readable?

80

This one should be annotated too.

132–135

This needs to be conditional on #if _LIBCPP_NO_EXCEPTIONS.

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

2

We typically call those increment.pass.cpp and decrement.pass.cpp.

[ldionne]

libcxx/include/__iterator/counted_iterator.h

74

[[no_unique_address]]?

83

_LIBCPP_ASSERT(__n >= 0, "message");? Might apply elsewhere we have Precondtions: in the spec.

108

Are you testing the noexcept-ness of this method in your tests? If not, you should, especially since it's in the spec.

118

Ditto for noexcept testing.

126

Precondition!

201

This should be __rhs.__count_ - __lhs.__count_. Also, if there's no test failing right now, we should add one that fails with this incorrect implementation.

223

Missing precondition check.

228

Suggestion: Move this right after operator-> to match the order it's in the spec.

260

Precondition.

268

Precondition.

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

17

Here and in all the other tests where the tested function doesn't require more than input_or_output_iterator, I'd like us to pass the input_or_output_iterator archetype as well. That will ensure we don't use capabilities we're not allowed to in the implementation.

60

Can you do:

std::counted_iterator<...>& result = (iter1 = iter2);

and also assert(&result == &iter1)? That makes sure we return the correct object.

72

Can we also add a test for when I == I2, i.e. assigning two iterators of the same type?

80

Can you add a test checking that !std::is_assignable<counted-iterator1, counted-iterator2> when the underlying iterators are not assignable? To ensure we properly constrain the template.

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

26

Suggestion: templatize that test and call it with the various iterator archetypes to remove a bit of duplication.

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

59

Suggestion: add assert(iter2 == iter1)

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

14

Can you have three files here? ctor.default.pass.cpp, etc.

108

For the converting constructor, let's add a static_assert(!std::is_constructible<counted_iterator, something-it-should-not-be-constructible-from>) to make sure we constrain the constructor properly.

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

58

Can we add a test that *it is SFINAE-d away when the underlying iterator isn't const-dereferenceable? To make sure we have the requires dereferenceable<const I> constraint.

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

46

We should check the noexcept-ness too.

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

22

What you just told me: This isn't an actual output_iterator since it's not indirectly_writable. So we should rename it. Maybe InputOrOutputArchetype (with a comment like // archetype for input_or_output_iterator)?

Also, this makes me think we should probably move that type in test_iterators.h (even though it's not *technically* an iterator).

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

14–24

Please split (you can leave the default_sentinel overloads in the same file).

72

using Counted?

73

And here you can declare it as Counted iter instead of using CTAD.

87

using Counted = std::counted_iterator<...> (without the const).

Then you just declare const Counted iter(...);, and you can get rid of the std::remove_const_t. WDYT?

150

Can you add the reason why?

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

26

Why don't you throw on operator++ instead? It seems like the try-catch in operator++(int) is probably meant to catch that more than throwing on copy (even though both are equally important).

114

Why not just iter++, without assigning the result?

121–130

I don't think you're testing anything of counted_iterator here, so I think we should remove this test altogether.

libcxx/test/support/test_iterators.h

648

Nice catch!

[zoecarver]

libcxx/include/__iterator/counted_iterator.h

74

Yes, the hidden friends need to use them.

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

26

This test we could easily do that for, but I like having it be as easy as possible to read. Your brain has to do the absolute minimum amount of work to understand what's going on here. It's harder to get wrong when all the types are concrete.

Also, if there's a failure, say for input_iterators, it will be way easier to catch this way, then looking through a substitution failure/back trace.

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

150

This is just to call out that the iterator doesn't have to be a random access iterator because we never actually touch the iterator itself when doing the minus operation (we subtract the counts).

[zoecarver]

Apply all review comments except for moving files around.

[zoecarver]

libcxx/include/__iterator/counted_iterator.h

40

AFAIU this macro doesn't actually do anything useful, so I'm not going to be applying it.

228

I went back and forth on this a lot. Ultimately I think it's better to have it in line with the synopsis because I think that's what people will reference more. However, I could easily be swayed to move it.

[zoecarver]

Apply final few review comments.

[ldionne]

LGTM pending comments and passing CI!

libcxx/include/__iterator/counted_iterator.h

40

It doesn't do anything useful *in this context* because we do not explicitly instantiate the type in the dylib.

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

22 ↗

(On Diff #361698)

Typo?

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

33

Weird comma separation.

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

61

// const versions?

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

22 ↗

(On Diff #361698)

Consider using ConvertibleTo<IterType> instead? That way, in the tests below, we can see more clearly what types you're trying to test for convertibility, instead of having to look at the conversion operator below.

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

21 ↗

(On Diff #361698)

We need to run the default constructor and make sure it initializes the iterator as it should.

Using = default to implement something is till an implementation, and we need to test that. For example, your test would pass if we never defined it at all, but users would get a linker error when they tried using the default ctor.

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

91 ↗

(On Diff #361698)

I still don't understand this comment. Based on what you just told me, perhaps you should write this instead:

// no need to use a random_access_iterator since counted_iterator doesn't actually subtract the underlying iterators

[zoecarver]

Apply review comments and fix CI.

[zoecarver]

Fix GCC.

[cjdb]

I'd like for some of the simple-ish noexcept specifiers to return, but LGTM.

libcxx/include/__iterator/counted_iterator.h

108

Why did the noexcept specifier removed? It's not a difficult one to get right and is arguably useful.

[• Quuxplusone]

(I didn't look at the tests.)

libcxx/include/__iterator/counted_iterator.h

108

noexcept specifiers are useful if-and-only-if someone has a use for them. For any function whose noexceptness is never used, marking it noexcept is unhelpful — and in fact may be harmful, because (even though I agree this one is "easy to get right") as soon as you get even one noexcept wrong, you end up with a rogue std::terminate. It is possible to introduce a bug by adding noexcept; it is not possible to introduce a bug by leaving it off. Combine this with the general mantra "The best code is no code," and you end up with my standard advice: Use noexcept on move constructors to avoid the vector pessimization, and (in libc++) use it where it's mandated by the paper standard, but otherwise play it safe and keep it simple.

235

This assertion is... confusing. My impression is that __count_ >= 0 is a class invariant. So -__n > __count_ would happen only when the user is trying to decrease by a large negative value, e.g. it -= -42; when it.count() < 42.
So the assertion is(?) correct; but the message should be more like "Attempted to advance a counted_iterator beyond the end of its range". (Compare the grammar to other _LIBCPP_ASSERTs, e.g. in <list>.)

264–267

This doesn't involve the three_way_comparable concept (just common_with), so couldn't you just land it now?

274

I recommend "Attempted to iter_move a non-dereferenceable counted_iterator"

284

I recommend "Attempted to iter_swap a non-dereferenceable counted_iterator"

[zoecarver]

libcxx/include/__iterator/counted_iterator.h

108

Why did the noexcept specifier removed? It's not a difficult one to get right and is arguably useful.

The noexcept specifier wasn't removed, this comment just moved.

235

Yes, I'll update the message to make it a bit clearer. Good idea.

274

I think what I have now is a bit clearer. If we answer the question, "why is the iterator non-dereferenceable" then we get the message I have here. And I think that's actually a simpler message; it gets the user to their solution more quickly.

[zoecarver]

Address review comments and fix 32bit CI.

[cjdb]

I just realised there's no iterator concept conformance test.

[zoecarver]

@cjdb iterator_traits.compile.pass.cpp L71.

[cjdb]

In D106205#2908612, @zoecarver wrote:

@cjdb iterator_traits.compile.pass.cpp L71.

Can you please move them out into their own file? We've adopted a convention now.

[zoecarver]

Apply feedback. Fix modules build. Move conformance tests into their own file as requested by Chriss.

libcxx/docs/Status/RangesPaper.csv

 [move.sentinel],,[predef.iterators],Unassigned,Not started
 [common.iterator],,"| [iterator.concepts]
 | [iterator.cust.swap]
 | [iterator.cust.move]",Zoe Carver,In Progress
 [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

libcxx/include/CMakeLists.txt

set(files
   __functional/unary_negate.h
   __functional/unwrap_ref.h
   __functional/weak_result_type.h
   __hash_table
   __iterator/access.h
   __iterator/advance.h
   __iterator/back_insert_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

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 <__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)
+
+// Named like this so they don't conflict with "__has_iterator_{concept,category}".
+template<class _Iter>
+concept __concept_has_iterator_concept = requires { typename _Iter::iterator_concept; };
+
+template<class>
+struct __counted_iterator_concept {};
+
+template<__concept_has_iterator_concept _Iter>
+struct __counted_iterator_concept<_Iter> {
+  using iterator_concept = typename _Iter::iterator_concept;
+};
+
+template<class _Iter>
+concept __concept_has_iterator_category = requires { typename _Iter::iterator_category; };
+
+template<class>
+struct __counted_iterator_category {};
+
+template<__concept_has_iterator_category _Iter>
+struct __counted_iterator_category<_Iter> {
+  using iterator_category = typename _Iter::iterator_category;
+};
+
+template<class>
+struct __counted_iterator_value_type {};
+
+template<input_iterator _Iter>
+struct __counted_iterator_value_type<_Iter> {
+  using value_type = typename _Iter::value_type;
+};
+
+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:
+  _Iter __current_ = _Iter();
+  iter_difference_t<_Iter> __count_ = 0;
+
+  using iterator_type = _Iter;
+  using difference_type = iter_difference_t<_Iter>;
+
+  constexpr counted_iterator() requires default_initializable<_Iter> = default;
+
+  constexpr counted_iterator(_Iter __iter, iter_difference_t<_Iter> __n)
+   : __current_(_VSTD::move(__iter)), __count_(__n) {}
+
+  template<class _I2>
+    requires convertible_to<const _I2&, _Iter>
+  constexpr counted_iterator(const counted_iterator<_I2>& __other)
+   : __current_(__other.__current_), __count_(__other.__count_) {}
+
+  template<class _I2>
+    requires assignable_from<_Iter&, const _I2&>
+  constexpr counted_iterator& operator=(const counted_iterator<_I2>& __other) {
+    __current_ = __other.__current_;
+    __count_ = __other.__count_;
+    return *this;
+  }
+
+  constexpr const _Iter& base() const& { return __current_; }
+  constexpr _Iter base() && { return _VSTD::move(__current_); }
+
+  constexpr iter_difference_t<_Iter> count() const noexcept { return __count_; }
+
+  constexpr decltype(auto) operator*() { return *__current_; }
+  constexpr decltype(auto) operator*() const
+    requires __referenceable<const _Iter> { return *__current_; }
+
+  constexpr auto operator->() const noexcept
+    requires contiguous_iterator<_Iter>
+  {
+    return _VSTD::to_address(__current_);
+  }
+
+  constexpr counted_iterator& operator++() {
+    ++__current_;
+    --__count_;
+    return *this;
+  }
+
+  decltype(auto) operator++(int) {
+    --__count_;
+    try { return __current_++; }
+    catch(...) { ++__count_; throw; }
+  }
+
+  constexpr counted_iterator operator++(int)
+    requires forward_iterator<_Iter>
+  {
+    counted_iterator __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  constexpr counted_iterator& operator--()
+    requires bidirectional_iterator<_Iter>
+  {
+    --__current_;
+    ++__count_;
+    return *this;
+  }
+
+  constexpr counted_iterator operator--(int)
+    requires bidirectional_iterator<_Iter>
+  {
+    counted_iterator __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  constexpr counted_iterator operator+(iter_difference_t<_Iter> __n) const
+    requires random_access_iterator<_Iter>
+  {
+    return counted_iterator(__current_ + __n, __count_ - __n);
+  }
+
+  friend constexpr counted_iterator operator+(
+    iter_difference_t<_Iter> __n, const counted_iterator& __x)
+    requires random_access_iterator<_Iter>
+  {
+    return __x + __n;
+  }
+
+  constexpr counted_iterator& operator+=(iter_difference_t<_Iter> __n)
+    requires random_access_iterator<_Iter>
+  {
+    __current_ += __n;
+    __count_ -= __n;
+    return *this;
+  }
+
+  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>
+  friend constexpr iter_difference_t<_I2> operator-(
+    const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs)
+  {
+    return __lhs.__count_ - __rhs.__count_;
+  }
+
+  friend constexpr iter_difference_t<_Iter> operator-(
+    const counted_iterator& __lhs, default_sentinel_t)
+  {
+    return -__lhs.__count_;
+  }
+
+  friend constexpr iter_difference_t<_Iter> operator-(
+    default_sentinel_t, const counted_iterator& __rhs)
+  {
+    return __rhs.__count_;
+  }
+
+  constexpr counted_iterator& operator-=(iter_difference_t<_Iter> __n)
+    requires random_access_iterator<_Iter>
+  {
+    __current_ -= __n;
+    __count_ += __n;
+    return *this;
+  }
+
+  constexpr decltype(auto) operator[](iter_difference_t<_Iter> __n) const
+    requires random_access_iterator<_Iter>
+  {
+    return __current_[__n];
+  }
+
+  template<common_with<_Iter> _I2>
+  friend constexpr bool operator==(
+    const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs)
+  {
+    return __lhs.__count_ == __rhs.__count_;
+  }
+
+  friend constexpr bool operator==(
+    const counted_iterator& __lhs, default_sentinel_t)
+  {
+    return __lhs.__count_ == 0;
+  }
+
+//   template<common_with<_Iter> _I2>
+//   friend constexpr strong_ordering operator<=>(
+//     const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs);
+
+  friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const counted_iterator& __i)
+    noexcept(noexcept(ranges::iter_move(__i.__current_)))
+      requires input_iterator<_Iter>
+  {
+    return ranges::iter_move(__i.__current_);
+  }
+
+  template<indirectly_swappable<_Iter> _I2>
+  friend constexpr void iter_swap(const counted_iterator& __x, const counted_iterator<_I2>& __y)
+    noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
+  {
+    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/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/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 {
     header "iterator"
     export *
 
     module __iterator {
       module access                { private header "__iterator/access.h" }
       module advance               { private header "__iterator/advance.h" }
       module back_insert_iterator  { private header "__iterator/back_insert_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" }

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;}
+};
+
+constexpr bool test() {
+  int buffer[8] = {1,2 ,3 , 4, 5, 6, 7, 8};
+
+  {
+    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);
+    iter1 = iter2;
+    assert(iter1.base().base() == buffer + 2);
+    assert(iter1.count() == 6);
+  }
+  {
+    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);
+    iter1 = iter2;
+    assert(iter1.base().base() == buffer + 2);
+    assert(iter1.count() == 6);
+  }
+
+  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"
+
+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*>);
+  }
+
+  {
+    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*>&);
+  }
+
+  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;}
+};
+
+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);
+      ++iter1;
+      assert(iter1 != iter2);
+    }
+  }
+
+  {
+    {
+      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));
+    }
+  }
+
+
+  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"
+
+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);
+  }
+
+  {
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+    for (unsigned i = 8; i != 0; --i, ++iter)
+      assert(iter.count() == i);
+  }
+
+  {
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+    for (unsigned i = 8; i != 0; --i, ++iter)
+      assert(iter.count() == i);
+  }
+
+  {
+    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);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/counted.iterator/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
+
+// 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"
+
+class ConvertibleIter
+{
+    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_;}
+
+    ConvertibleIter() = default;
+    explicit constexpr ConvertibleIter(int *it) : it_(it) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr ConvertibleIter& operator++() {++it_; return *this;}
+    constexpr ConvertibleIter operator++(int)
+        {ConvertibleIter tmp(*this); ++(*this); return tmp;}
+
+    constexpr operator forward_iterator<int*>() const { return forward_iterator<int*>(it_); }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    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 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);
+    }
+
+    {
+      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);
+    }
+  }
+
+  {
+    {
+      std::counted_iterator iter1(ConvertibleIter{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(ConvertibleIter{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/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"
+
+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 (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);
+  }
+
+  {
+    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);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  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"
+
+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&&);
+  }
+
+  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"
+
+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);
+  }
+
+  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 OutputIterator {
+  using difference_type = int;
+
+  int operator*();
+  void operator++(int);
+  OutputIterator& 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<OutputIterator>;
+    static_assert(std::same_as<Iter::iterator_type, OutputIterator>);
+    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.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>;
+// template<common_with<I> I2>
+//   friend constexpr iter_difference_t<I2> operator-(
+//     const counted_iterator& x, const counted_iterator<I2>& y);
+// 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);
+// constexpr counted_iterator& operator-=(iter_difference_t<I> n)
+//   requires random_access_iterator<I>;
+
+#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;}
+};
+
+template<class Iter>
+concept MinusEnabled = requires(Iter& iter) {
+  iter - 1;
+};
+
+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_t = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer + 2}, 6);
+      assert(iter - 2 == counted_t(random_access_iterator<int*>{buffer}, 8));
+      assert(iter - 0 == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+      assert(iter.count() == 6);
+
+      ASSERT_SAME_TYPE(decltype(iter - 2), counted_t);
+    }
+    {
+      using counted_t = const std::counted_iterator<random_access_iterator<int*>>;
+      const std::counted_iterator iter(random_access_iterator<int*>{buffer + 2}, 6);
+      assert(iter - 2 == counted_t(random_access_iterator<int*>{buffer}, 8));
+      assert(iter - 0 == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+      assert(iter.count() == 6);
+
+      ASSERT_SAME_TYPE(decltype(iter - 2), std::remove_const_t<counted_t>);
+    }
+    {
+      using counted_t = std::counted_iterator<contiguous_iterator<int*>>;
+      std::counted_iterator iter(contiguous_iterator<int*>{buffer + 2}, 6);
+      assert(iter - 2 == counted_t(contiguous_iterator<int*>{buffer}, 8));
+      assert(iter - 0 == counted_t(contiguous_iterator<int*>{buffer + 2}, 6));
+      assert(iter.count() == 6);
+
+      ASSERT_SAME_TYPE(decltype(iter - 2), counted_t);
+    }
+    {
+      using counted_t = const std::counted_iterator<contiguous_iterator<int*>>;
+      const std::counted_iterator iter(contiguous_iterator<int*>{buffer + 2}, 6);
+      assert(iter - 2 == counted_t(contiguous_iterator<int*>{buffer}, 8));
+      assert(iter - 0 == counted_t(contiguous_iterator<int*>{buffer + 2}, 6));
+      assert(iter.count() == 6);
+
+      ASSERT_SAME_TYPE(decltype(iter - 2), std::remove_const_t<counted_t>);
+    }
+  }
+
+  {
+    {
+      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*>);
+    }
+    // Note: not using random_access_iterator here.
+    {
+      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*>);
+    }
+  }
+
+  {
+    {
+      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*>);
+    }
+  }
+
+  {
+    {
+      using counted_t = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer + 2}, 6);
+      assert((iter -= 2) == counted_t(random_access_iterator<int*>{buffer}, 8));
+      assert((iter -= 0) == counted_t(random_access_iterator<int*>{buffer}, 8));
+      assert(iter.count() == 8);
+
+      ASSERT_SAME_TYPE(decltype(iter -= 2), counted_t&);
+    }
+    {
+      using counted_t = std::counted_iterator<contiguous_iterator<int*>>;
+      std::counted_iterator iter(contiguous_iterator<int*>{buffer + 2}, 6);
+      assert((iter -= 2) == counted_t(contiguous_iterator<int*>{buffer}, 8));
+      assert((iter -= 0) == counted_t(contiguous_iterator<int*>{buffer}, 8));
+      assert(iter.count() == 8);
+
+      ASSERT_SAME_TYPE(decltype(iter -= 2), counted_t&);
+    }
+    {
+      static_assert( MinusEnabled<std::counted_iterator<random_access_iterator<int*>>>);
+      static_assert(!MinusEnabled<std::counted_iterator<bidirectional_iterator<int*>>>);
+
+      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_minus.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_t = std::counted_iterator<bidirectional_iterator<int*>>;
+    std::counted_iterator iter(bidirectional_iterator<int*>{buffer + 2}, 6);
+    assert(iter-- == counted_t(bidirectional_iterator<int*>{buffer + 2}, 6));
+    assert(--iter == counted_t(bidirectional_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter--), counted_t);
+    ASSERT_SAME_TYPE(decltype(--iter), counted_t&);
+  }
+  {
+    using counted_t = std::counted_iterator<random_access_iterator<int*>>;
+    counted_t iter(random_access_iterator<int*>{buffer + 2}, 6);
+    assert(iter-- == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+    assert(--iter == counted_t(random_access_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter--), counted_t);
+    ASSERT_SAME_TYPE(decltype(--iter), counted_t&);
+  }
+  {
+    using counted_t = std::counted_iterator<contiguous_iterator<int*>>;
+    std::counted_iterator iter(contiguous_iterator<int*>{buffer + 2}, 6);
+    assert(iter-- == counted_t(contiguous_iterator<int*>{buffer + 2}, 6));
+    assert(--iter == counted_t(contiguous_iterator<int*>{buffer}, 8));
+    assert(iter.count() == 8);
+
+    ASSERT_SAME_TYPE(decltype(iter--), counted_t);
+    ASSERT_SAME_TYPE(decltype(--iter), counted_t&);
+  }
+
+  {
+    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/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_t = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(iter + 2 == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+      assert(iter + 0 == counted_t(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), counted_t);
+    }
+    {
+      using counted_t = const std::counted_iterator<random_access_iterator<int*>>;
+      const std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(iter + 8 == counted_t(random_access_iterator<int*>{buffer + 8}, 0));
+      assert(iter + 0 == counted_t(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), std::remove_const_t<counted_t>);
+    }
+  }
+
+  {
+    {
+      using counted_t = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(2 + iter == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+      assert(0 + iter == counted_t(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), counted_t);
+    }
+    {
+      using counted_t = const std::counted_iterator<random_access_iterator<int*>>;
+      const std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert(8 + iter == counted_t(random_access_iterator<int*>{buffer + 8}, 0));
+      assert(0 + iter == counted_t(random_access_iterator<int*>{buffer}, 8));
+
+      ASSERT_SAME_TYPE(decltype(iter + 2), std::remove_const_t<counted_t>);
+    }
+  }
+
+  {
+    {
+      using counted_t = std::counted_iterator<random_access_iterator<int*>>;
+      std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+      assert((iter += 2) == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+      assert((iter += 0) == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+
+      ASSERT_SAME_TYPE(decltype(iter += 2), counted_t&);
+    }
+    {
+      using counted_t = std::counted_iterator<contiguous_iterator<int*>>;
+      std::counted_iterator iter(contiguous_iterator<int*>{buffer}, 8);
+      assert((iter += 8) == counted_t(contiguous_iterator<int*>{buffer + 8}, 0));
+      assert((iter += 0) == counted_t(contiguous_iterator<int*>{buffer + 8}, 0));
+
+      ASSERT_SAME_TYPE(decltype(iter += 2), counted_t&);
+    }
+    {
+      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/plus_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++();
+// 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 ThrowsOnCopy
+{
+    It it_;
+    int count_ = 0;
+
+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_;}
+
+    ThrowsOnCopy() = default;
+    constexpr ThrowsOnCopy(ThrowsOnCopy const& other) : count_(other.count_ + 1) {
+      if (count_ > 1)
+        throw 42;
+    }
+    explicit constexpr ThrowsOnCopy(It it) : it_(it) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr ThrowsOnCopy& operator++() {++it_; return *this;}
+    constexpr ThrowsOnCopy operator++(int)
+        {ThrowsOnCopy tmp(*this); ++(*this); return tmp;}
+};
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+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_t = std::counted_iterator<forward_iterator<int*>>;
+    std::counted_iterator iter(forward_iterator<int*>{buffer}, 8);
+
+    assert(iter++ == counted_t(forward_iterator<int*>{buffer}, 8));
+    assert(++iter == counted_t(forward_iterator<int*>{buffer + 2}, 6));
+
+    ASSERT_SAME_TYPE(decltype(iter++), counted_t);
+    ASSERT_SAME_TYPE(decltype(++iter), counted_t&);
+  }
+  {
+    using counted_t = std::counted_iterator<random_access_iterator<int*>>;
+    std::counted_iterator iter(random_access_iterator<int*>{buffer}, 8);
+
+    assert(iter++ == counted_t(random_access_iterator<int*>{buffer}, 8));
+    assert(++iter == counted_t(random_access_iterator<int*>{buffer + 2}, 6));
+
+    ASSERT_SAME_TYPE(decltype(iter++), counted_t);
+    ASSERT_SAME_TYPE(decltype(++iter), counted_t&);
+  }
+
+  {
+    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());
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    using counted_t = std::counted_iterator<cpp20_input_iterator<int*>>;
+    std::counted_iterator iter(cpp20_input_iterator<int*>{buffer}, 8);
+
+    iter++;
+    assert(++iter == counted_t(cpp20_input_iterator<int*>{buffer + 2}, 6));
+
+    ASSERT_SAME_TYPE(decltype(iter++), void);
+    ASSERT_SAME_TYPE(decltype(++iter), counted_t&);
+  }
+  {
+    using counted_t = std::counted_iterator<ThrowsOnCopy<int*>>;
+    std::counted_iterator iter(ThrowsOnCopy<int*>{buffer}, 8);
+    try {
+      auto other = iter++;
+      (void)other;
+      assert(false);
+    } catch (int x) {
+      assert(x == 42);
+      assert(iter.count() == 8);
+    }
+    try {
+      auto other = ++iter;
+      (void)other;
+      assert(false);
+    } catch (int x) {
+      assert(x == 42);
+      // TODO: LWG issue! This should be 8.
+      // We're missing a try-catch block around the second return.
+      assert(iter.count() == 7);
+    }
+
+    ASSERT_SAME_TYPE(decltype(iter++), ThrowsOnCopy<int*>);
+    ASSERT_SAME_TYPE(decltype(++iter), counted_t&);
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  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/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)) {}