[libcxx][iterator][ranges] adds `forward_iterator` and `forward_range`

[cjdb]

Summary

Implements parts of:

• P0896R4 The One Ranges Proposal`

Depends on D100271.

[cjdb]

updates subsumption test

[miscco]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/forward_iterator.compile.pass.cpp

157

Feel free to disregard: That line gets drowned a bit. Should we add a banner above it?

159

I do not really like that name. We should say *why* it is not a input iterator without checking all the methods.

I think here it is not_eq_comparable_iterator. Ditto my wish for porting the iterator test machinery

[cjdb]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/forward_iterator.compile.pass.cpp

157

Nice observation. I'll move this test (and the one below) above the namespace standard_types the next time I visit this commit (too busy to rebase this instant).

159

I do not really like that name. We should say *why* it is not a input iterator without checking all the methods.

The salient feature here isn't why the type is not an input iterator: only that it isn't an input iterator (since all forward iterators are input iterators, a non-input iterator cannot be a forward iterator). Either way, I consider it important to assert that input_iterator isn't satisfied, to document that this case has been checked.

[cjdb]

rebases so @zoecarver isn't blocked

This patch is not ready for another round of reviews

[zoecarver]

This patch is not ready for another round of reviews

FYI there is the planned changes action on Phab. That will move it out of the review queue.

[cjdb]

• moves conformance tests to appropriate files
• adds canonical test type cxx20_forward_iterator
• adds test for non-equality comparable iterator

[cjdb]

removes old test_forward_iterator type

[ldionne]

LGTM except the testing bits.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/forward_iterator.compile.pass.cpp

29

This should be removed with the new direction IIUC.

libcxx/test/support/test_iterators.h

671

I thought we had that discussion before, but why are we adding this type? Why can't we use just the existing forward_iterator? They are not materially different.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[zoecarver]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/forward_iterator.compile.pass.cpp

8

Please add two more tests:

1. No forward_iterator_tag
2. Not incrementable.

28

Do we still need the TODO here?

35

You don't have to take this comment, but maybe add a simple iterator that is a forward_iterator so that it's immediately obvious how the below types differ. Better yet, comment out the missing members.

45

Nit: Can you either give these all their own line or make them individual static asserts?

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/subsumption.compile.pass.cpp

22

This either needs to be a libcxx only test or it needs to not use _ITER_CONCEPT.

[zoecarver]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/forward_iterator.compile.pass.cpp

35

Also, shouldn't this type be comparable?

[cjdb]

• adds conformance tests
• moves subsumption test from test/std to test/libcxx

[cjdb]

• adds not_incrementable and bad_iterator_concept tests
• removes some old code

[cjdb]

libcxx/test/support/test_iterators.h

671

Whoops, I forgot to delete this.

[ldionne]

This LGTM pending CI (and the removal of XFAILs if I'm right about that).

libcxx/test/std/ranges/range.refinements/forward_range.compile.pass.cpp

13

I think we don't want those XFAILs anymore?

[cjdb]

removes XFAIL

[zoecarver]

libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp

17 ↗

(On Diff #342452)

I think we're missing a corresponding range_conformance test for set.

libcxx/include/__iterator/concepts.h

 // [iterator.concept.input]
 template<class _Ip>
 concept input_iterator =
   input_or_output_iterator<_Ip> &&
   indirectly_readable<_Ip> &&
   requires { typename _ITER_CONCEPT<_Ip>; } &&
   derived_from<_ITER_CONCEPT<_Ip>, input_iterator_tag>;
 
+// [iterator.concept.forward]
+template<class _Ip>
+concept forward_iterator =
+  input_iterator<_Ip> &&
+  derived_from<_ITER_CONCEPT<_Ip>, forward_iterator_tag> &&
+  incrementable<_Ip> &&
+  sentinel_for<_Ip, _Ip>;
+
 // clang-format on
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_CONCEPTS_H

libcxx/include/__ranges/concepts.h

namespace ranges {
   template <range _Rp>
   using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rp> >;
 
   // [range.refinements], other range refinements
   template <class _Tp>
   concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp> >;
 
   template <class _Tp>
+  concept forward_range = input_range<_Tp> && forward_iterator<iterator_t<_Tp> >;
+
+  template <class _Tp>
   concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp> >;
+
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 // clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_RANGES_CONCEPTS_H

libcxx/include/iterator

 
 template<class S, class I>
   concept sized_sentinel_for = see below;
 
 // [iterator.concept.input], concept input_­iterator
 template<class I>
   concept input_iterator = see below;                      // since C++20
 
+// [iterator.concept.forward], concept forward_­iterator
+template<class I>
+  concept forward_iterator = see below;                    // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;

libcxx/include/ranges

template<range R>
     using range_reference_t = iter_reference_t<iterator_t<R>>;
   template<range R>
     using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
 
   // [range.refinements], other range refinements
   template<class T>
     concept input_range = see below;
 
+  template<class T>
+    concept forward_range = see below;
+
   template <class _Tp>
     concept common_range = see below;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>

libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::map<int, int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::multimap<int, int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::multiset<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::array<int, 10>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::deque<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::forward_list<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::list<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::vector<bool>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::vector<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::unordered_map<int, int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::unordered_multimap<int, int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::unordered_multiset<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::unordered_set<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp

 #include <concepts>
 #include <ranges>
 
 using range = std::span<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
+static_assert(stdr::forward_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::iterator>);
 static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range const>);
+static_assert(stdr::forward_range<range const>);

libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp

 
 #include <concepts>
 #include <ranges>
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<fs::path>, fs::path::iterator>);
 static_assert(stdr::common_range<fs::path>);
-static_assert(stdr::input_range<fs::path>);
+static_assert(stdr::forward_range<fs::path>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::path const>, fs::path::const_iterator>);
 static_assert(stdr::common_range<fs::path const>);
-static_assert(stdr::input_range<fs::path const>);
+static_assert(stdr::forward_range<fs::path const>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/forward_iterator.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
+// XFAIL: msvc && clang
+
+// std::forward_iterator;
+
+#include <iterator>
+
+#include <concepts>
+
+#include "test_iterators.h"
+
+static_assert(std::forward_iterator<forward_iterator<int*> >);
+static_assert(std::forward_iterator<bidirectional_iterator<int*> >);
+static_assert(std::forward_iterator<random_access_iterator<int*> >);
+static_assert(std::forward_iterator<contiguous_iterator<int*> >);
+
+// TODO: add new `cxx20_*_iterator`s as they're added
+static_assert(!std::forward_iterator<cpp20_input_iterator<int*> >);
+
+static_assert(std::forward_iterator<int*>);
+static_assert(std::forward_iterator<int const*>);
+static_assert(std::forward_iterator<int volatile*>);
+static_assert(std::forward_iterator<int const volatile*>);
+
+struct not_input_iterator {
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = std::forward_iterator_tag;
+
+  int operator*() const;
+
+  not_input_iterator& operator++();
+  not_input_iterator operator++(int);
+};
+static_assert(std::input_or_output_iterator<not_input_iterator> && !std::input_iterator<not_input_iterator> &&
+              !std::forward_iterator<not_input_iterator>);
+
+struct not_equality_comparable {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = std::forward_iterator_tag;
+
+  int operator*() const;
+
+  not_equality_comparable& operator++();
+  not_equality_comparable operator++(int);
+};
+static_assert(std::input_iterator<not_equality_comparable> && !std::forward_iterator<not_equality_comparable>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.forward/subsumption.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
 // XFAIL: msvc && clang
 
-// template<class T>
-// concept input_iterator;
-
-#include <ranges>
+// std::forward_iterator;
 
 #include <iterator>
 
-struct range {
-  int* begin();
-  int* end();
-};
+#include <concepts>
 
 // clang-format off
-template<std::ranges::range R>
-requires std::input_iterator<std::ranges::iterator_t<R> >
-[[nodiscard]] constexpr bool check_input_range_subsumption() {
+template<std::input_iterator I>
+requires std::derived_from<std::_ITER_CONCEPT<I>, std::forward_iterator_tag>
+[[nodiscard]] constexpr bool check_subsumption() {
   return false;
 }
 
-template<std::ranges::input_range>
+template<std::forward_iterator>
 requires true
-[[nodiscard]] constexpr bool check_input_range_subsumption() {
+[[nodiscard]] constexpr bool check_subsumption() {
   return true;
 }
 // clang-format on
 
-static_assert(check_input_range_subsumption<range>());
+static_assert(check_subsumption<int*>());

libcxx/test/std/ranges/range.refinements/forward_range.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// std::ranges::forward_range;
+
+#include <ranges>
+
+#include "test_iterators.h"
+#include "test_range.h"
+
+namespace stdr = std::ranges;
+
+template <template <class...> class I>
+constexpr bool check_forward_range() {
+  constexpr bool result = stdr::forward_range<test_range<I> >;
+  static_assert(stdr::forward_range<test_range<I> const> == result);
+  static_assert(stdr::forward_range<test_non_const_common_range<I> > == result);
+  static_assert(stdr::forward_range<test_non_const_range<I> > == result);
+  static_assert(stdr::forward_range<test_common_range<I> > == result);
+  static_assert(stdr::forward_range<test_common_range<I> const> == result);
+  static_assert(!stdr::forward_range<test_non_const_common_range<I> const>);
+  static_assert(!stdr::forward_range<test_non_const_range<I> const>);
+  return result;
+}
+
+static_assert(!check_forward_range<input_iterator>());
+static_assert(!check_forward_range<cpp20_input_iterator>());
+static_assert(check_forward_range<forward_iterator>());
+static_assert(check_forward_range<bidirectional_iterator>());
+static_assert(check_forward_range<random_access_iterator>());
+static_assert(check_forward_range<contiguous_iterator>());

libcxx/test/std/ranges/range.refinements/subsumption.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
 // XFAIL: msvc && clang
 
 // template<class T>
 // concept input_iterator;
 
+// std::ranges::forward_range
+
 #include <ranges>
 
 #include <iterator>
 
 struct range {
   int* begin();
   int* end();
 };
 
 // clang-format off
 template<std::ranges::range R>
 requires std::input_iterator<std::ranges::iterator_t<R> >
 [[nodiscard]] constexpr bool check_input_range_subsumption() {
   return false;
 }
 
 template<std::ranges::input_range>
 requires true
 [[nodiscard]] constexpr bool check_input_range_subsumption() {
   return true;
 }
 // clang-format on
 
 static_assert(check_input_range_subsumption<range>());
+
+// clang-format off
+template<std::ranges::input_range R>
+requires std::forward_iterator<std::ranges::iterator_t<R> >
+[[nodiscard]] constexpr bool check_forward_range_subsumption() {
+  return false;
+}
+
+template<std::ranges::forward_range>
+requires true
+[[nodiscard]] constexpr bool check_forward_range_subsumption() {
+  return true;
+}
+// clang-format on
+
+static_assert(check_forward_range_subsumption<range>());

libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp

 
 #include <concepts>
 #include <ranges>
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<std::cmatch>, std::cmatch::iterator>);
 static_assert(stdr::common_range<std::cmatch>);
-static_assert(stdr::input_range<std::cmatch>);
+static_assert(stdr::forward_range<std::cmatch>);
 
 static_assert(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
 static_assert(stdr::common_range<std::cmatch const>);
-static_assert(stdr::input_range<std::cmatch const>);
+static_assert(stdr::forward_range<std::cmatch const>);

libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp

 
 #include <concepts>
 #include <ranges>
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<std::string>, std::string::iterator>);
 static_assert(stdr::common_range<std::string>);
-static_assert(stdr::input_range<std::string>);
+static_assert(stdr::forward_range<std::string>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
 static_assert(stdr::common_range<std::string const>);
-static_assert(stdr::input_range<std::string const>);
+static_assert(stdr::forward_range<std::string const>);

libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp

 
 #include <concepts>
 #include <ranges>
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<std::string_view>, std::string_view::iterator>);
 static_assert(stdr::common_range<std::string_view>);
-static_assert(stdr::input_range<std::string_view>);
+static_assert(stdr::forward_range<std::string_view>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
 static_assert(stdr::common_range<std::string_view const>);
-static_assert(stdr::input_range<std::string_view const>);
+static_assert(stdr::forward_range<std::string_view const>);

libcxx/test/support/test_iterators.h

struct cpp20_input_iterator {
   [[nodiscard]] I const& base() const& { return base_; }
 
   [[nodiscard]] I base() && { return std::move(base_); }
 
 private:
   I base_ = I();
 };
 
+template <class I>
+struct cxx20_forward_iterator {
+  using value_type = std::iter_value_t<I>;
+  using difference_type = std::iter_difference_t<I>;
+  using iterator_concept = std::forward_iterator_tag;
+
+  cxx20_forward_iterator() = default;
+
+  explicit constexpr cxx20_forward_iterator(I base) : base_(std::move(base)) {}
+
+  constexpr decltype(auto) operator*() const { return *base_; }
+
+  cxx20_forward_iterator& operator++() {
+    ++base_;
+    return *this;
+  }
+  cxx20_forward_iterator operator++(int) {
+    auto temp = *this;
+    ++*this;
+    return *this;
+  }
+
+  bool operator==(cxx20_forward_iterator const&) const = default;
+
+private:
+  I base_ = I();
+};
+
 #endif // TEST_STD_VER > 17 && defined(__cpp_lib_concepts)
 
 #undef DELETE_FUNCTION
 
 #endif // ITERATORS_H