[libcxx][iterator][ranges] adds `input_iterator` and `input_range`

[cjdb]

Summary

Implements parts of:

• P0896R4 The One Ranges Proposal`

Depends on D100269.

[cjdb]

updates synopsis, rebases to activate CI

[cjdb]

adds subsumption tests

[cjdb]

updates subsumption test

[miscco]

I like the test coverage but I believe that we should get @CaseyCarter on board to port the ranges test machinery over. It is quite extensive and rebuilding it for the fun of it seems a waste of time

[cjdb]

In D100271#2684903, @miscco wrote:

I like the test coverage but I believe that we should get @CaseyCarter on board to port the ranges test machinery over. It is quite extensive and rebuilding it for the fun of it seems a waste of time

The intention is for there to be a libc++ test suite and an MSVC STL test suite. It improves coverage and also lets us respect the different project test structures without being intrusive.
MSVC tests will be added once they can be, and after we get a script happening (I consider it P3 in terms of libc++; P6 when factoring in my day job's responsibilities).

[cjdb]

rebases to activate CI

[cjdb]

rebases so @zoecarver isn't blocked

This patch is not ready for another round of reviews

[cjdb]

• replaces monolithic test with conformance tests
• adds canonical test type cxx20_input_iterator

[cjdb]

fixes guards around cxx20_input_iterator

[cjdb]

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

30

Should be range const (note to reviewers: please flag these as you see them so I don't miss any).

[zoecarver]

LGTM.

libcxx/test/support/test_iterators.h

638

Side note: I know we sort of already started down the road of cxx20_ naming, but part of me doesn't really like this, because hopefully (and probably) this will just be "The Future of Iterators" so it would be great if we could name the other iterators "legacy" or whatever and make these new iterators seem as though they aren't the alternative. I don't know if this is feasible, or worth of the time it might cost, though.

libcxx/test/support/test_macros.h

321

😍

[cjdb]

libcxx/test/support/test_iterators.h

638

D101242 takes care of renaming all the existing iterators. cxx20_ is to make it unambiguous for non-ranges contributors that it's different (this optimises for the reader).

[• Quuxplusone]

libcxx/test/support/test_iterators.h

638

Actually, what you should do in test_iterators.h is simply make sure that our existing input_iterator is a std::input_iterator; that our existing forward_iterator is a std::forward_iterator; etc. If they don't conform to the C++20 concepts, then that is a bug worth fixing. (But I believe they do conform.)

If our existing test_iterators.h already provides C++20-compatible iterators (which, again, is the intention — and I recently even added a C++20 contiguous_iterator to this file!), then there's nothing to do here.

[cjdb]

libcxx/test/support/test_iterators.h

638

Actually, this is an important new test type for algorithms, iterator adaptors, and range adaptors.

[ldionne]

This looks OK to me apart from the input_iterator archetype naming.

libcxx/test/support/test_iterators.h

638

I'm talking to Chris offline about this, but what I'd want:

legacy_input_iterator or cpp17_input_iterator => archetype for the "old" InputIterator concept, which includes copyability
input_iterator => archetype for the new, C++20 std::input_iterator concept, without copyability

Since the other iterators don't change in any meaningful way, we shouldn't introduce new names for those.

[ldionne]

Reached offline agreement with @cjdb about using cpp20_input_iterator here. Chris, please change to that instead of cxx20 and ship it.

Other reviewers, please say it if you have a blocking objection with that direction, otherwise I think we've spent far enough energy on this name selection.

[cjdb]

renames cxx20_input_iterator to cpp20_input_iterator

[cjdb]

rebases to activate CI

[zoecarver]

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

24

Same comment as D100275 wrt using _ITER_CONCEPT here.

[cjdb]

moves subsumption test to test/libcxx

[cjdb]

removes zero-width code point from comment

libcxx/include/__iterator/concepts.h

 
 // [iterator.concept.sentinel]
 template<class _Sp, class _Ip>
 concept sentinel_for =
   semiregular<_Sp> &&
   input_or_output_iterator<_Ip> &&
   __weakly_equality_comparable_with<_Sp, _Ip>;
 
+// [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>;
+
 // 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

 // -*- C++ -*-
 //===--------------------- __ranges/concepts.h ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_RANGES_CONCEPTS_H
 #define _LIBCPP_RANGES_CONCEPTS_H
 
 #include <__config>
+#include <__iterator/concepts.h>
 #include <__ranges/begin.h>
 #include <__ranges/end.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
namespace ranges {
   template <range _Rp>
   using range_reference_t = iter_reference_t<iterator_t<_Rp> >;
 
   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 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

 // [iterator.concept.iterator], concept input_­or_­output_­iterator
   template<class I>
     concept input_or_output_iterator = see below;          // since C++20
 
 // [iterator.concept.sentinel], concept sentinel_­for
 template<class S, class I>
   concept sentinel_for = see below;                        // since C++20
 
+// [iterator.concept.input], concept input_­iterator
+template<class I>
+  concept input_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

namespace std::ranges {
   template<range R>
     using range_value_t = iter_value_t<iterator_t<R>>;
   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 _Tp>
     concept common_range = see below;
 }
 
 */
 
 #include <__config>
 #include <__ranges/begin.h>

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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

 #include <concepts>
 #include <ranges>
 
 using range = std::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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
+static_assert(stdr::input_range<range>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, int>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp

 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);
 static_assert(!std::sentinel_for<iterator, const_local_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(!std::sentinel_for<const_iterator, local_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(std::incrementable<local_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<local_iterator, iterator>);
 static_assert(!std::sentinel_for<local_iterator, const_iterator>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::incrementable<const_local_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, const_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_local_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);
 static_assert(!std::sentinel_for<iterator, const_local_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, local_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
 static_assert(std::incrementable<local_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<local_iterator, iterator>);
 static_assert(!std::sentinel_for<local_iterator, const_iterator>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::incrementable<const_local_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, const_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_local_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);
 static_assert(!std::sentinel_for<iterator, const_local_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, local_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
 static_assert(std::incrementable<local_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<local_iterator, iterator>);
 static_assert(!std::sentinel_for<local_iterator, const_iterator>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::incrementable<const_local_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, const_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_local_iterator>);

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(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>);

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

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);
 static_assert(!std::sentinel_for<iterator, const_local_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(!std::sentinel_for<const_iterator, local_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(std::incrementable<local_iterator>);
 static_assert(std::input_or_output_iterator<local_iterator>);
 static_assert(!std::sentinel_for<local_iterator, iterator>);
 static_assert(!std::sentinel_for<local_iterator, const_iterator>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::incrementable<const_local_iterator>);
 static_assert(std::input_or_output_iterator<const_local_iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, iterator>);
 static_assert(!std::sentinel_for<const_local_iterator, const_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
+static_assert(std::input_iterator<const_local_iterator>);

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(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>);

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(std::same_as<stdr::iterator_t<range const>, range::iterator>);
 static_assert(stdr::common_range<range const>);
+static_assert(stdr::input_range<range const>);

libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp

 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
+static_assert(std::input_iterator<iterator>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 static_assert(std::indirectly_readable<fs::directory_iterator>);
 static_assert(!std::indirectly_writable<fs::directory_iterator, fs::directory_iterator::value_type>);
 static_assert(std::weakly_incrementable<fs::directory_iterator>);
 static_assert(!std::incrementable<fs::directory_iterator>);
 static_assert(std::input_or_output_iterator<fs::directory_iterator>);
 static_assert(std::sentinel_for<fs::directory_iterator, fs::directory_iterator>);
+static_assert(std::input_iterator<fs::directory_iterator>);
 
 static_assert(std::indirectly_readable<fs::recursive_directory_iterator>);
 static_assert(
     !std::indirectly_writable<fs::recursive_directory_iterator, fs::recursive_directory_iterator::value_type>);
 static_assert(std::weakly_incrementable<fs::recursive_directory_iterator>);
 static_assert(!std::incrementable<fs::recursive_directory_iterator>);
 static_assert(std::input_or_output_iterator<fs::recursive_directory_iterator>);
 static_assert(std::sentinel_for<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
+static_assert(std::input_iterator<fs::recursive_directory_iterator>);

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

 
 #include <concepts>
 #include <ranges>
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
 static_assert(stdr::common_range<fs::directory_iterator>);
+static_assert(stdr::input_range<fs::directory_iterator>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
 static_assert(stdr::common_range<fs::directory_iterator const>);
+static_assert(stdr::input_range<fs::directory_iterator const>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
 static_assert(stdr::common_range<fs::recursive_directory_iterator>);
+static_assert(stdr::input_range<fs::directory_iterator>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
 static_assert(stdr::common_range<fs::recursive_directory_iterator const>);
+static_assert(stdr::input_range<fs::directory_iterator 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(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>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/input_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
+
+// template<class T>
+// concept input_iterator;
+
+#include <iterator>
+
+#include "test_iterators.h"
+
+static_assert(std::input_iterator<input_iterator<int*> >);
+static_assert(std::input_iterator<cxx20_input_iterator<int*> >);
+
+struct no_explicit_iter_concept {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+
+  no_explicit_iter_concept() = default;
+
+  no_explicit_iter_concept(no_explicit_iter_concept&&) = default;
+  no_explicit_iter_concept& operator=(no_explicit_iter_concept&&) = default;
+
+  no_explicit_iter_concept(no_explicit_iter_concept const&) = delete;
+  no_explicit_iter_concept& operator=(no_explicit_iter_concept const&) = delete;
+
+  value_type operator*() const;
+
+  no_explicit_iter_concept& operator++();
+  void operator++(int);
+};
+// ITER-CONCEPT is `random_access_iterator_tag` >:(
+static_assert(std::input_iterator<no_explicit_iter_concept>);
+
+static_assert(std::input_iterator<int*>);
+static_assert(std::input_iterator<int const*>);
+static_assert(std::input_iterator<int volatile*>);
+static_assert(std::input_iterator<int const volatile*>);
+
+struct not_weakly_incrementable {
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  not_weakly_incrementable() = default;
+
+  not_weakly_incrementable(not_weakly_incrementable&&) = default;
+  not_weakly_incrementable& operator=(not_weakly_incrementable&&) = default;
+
+  not_weakly_incrementable(not_weakly_incrementable const&) = delete;
+  not_weakly_incrementable& operator=(not_weakly_incrementable const&) = delete;
+
+  int operator*() const;
+
+  not_weakly_incrementable& operator++();
+};
+static_assert(!std::input_or_output_iterator<not_weakly_incrementable> &&
+              !std::input_iterator<not_weakly_incrementable>);
+
+struct not_indirectly_readable {
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  not_indirectly_readable() = default;
+
+  not_indirectly_readable(not_indirectly_readable&&) = default;
+  not_indirectly_readable& operator=(not_indirectly_readable&&) = default;
+
+  not_indirectly_readable(not_indirectly_readable const&) = delete;
+  not_indirectly_readable& operator=(not_indirectly_readable const&) = delete;
+
+  int operator*() const;
+
+  not_indirectly_readable& operator++();
+  void operator++(int);
+};
+static_assert(!std::indirectly_readable<not_indirectly_readable> && !std::input_iterator<not_indirectly_readable>);
+
+struct bad_iterator_category {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+  using iterator_category = void;
+
+  bad_iterator_category() = default;
+
+  bad_iterator_category(bad_iterator_category&&) = default;
+  bad_iterator_category& operator=(bad_iterator_category&&) = default;
+
+  bad_iterator_category(bad_iterator_category const&) = delete;
+  bad_iterator_category& operator=(bad_iterator_category const&) = delete;
+
+  value_type operator*() const;
+
+  bad_iterator_category& operator++();
+  void operator++(int);
+};
+static_assert(!std::input_iterator<bad_iterator_category>);
+
+struct bad_iterator_concept {
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+  using iterator_concept = void*;
+
+  bad_iterator_concept() = default;
+
+  bad_iterator_concept(bad_iterator_concept&&) = default;
+  bad_iterator_concept& operator=(bad_iterator_concept&&) = default;
+
+  bad_iterator_concept(bad_iterator_concept const&) = delete;
+  bad_iterator_concept& operator=(bad_iterator_concept const&) = delete;
+
+  value_type operator*() const;
+
+  bad_iterator_concept& operator++();
+  void operator++(int);
+};
+static_assert(!std::input_iterator<bad_iterator_concept>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.input/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
 
-// multiset
+// template<class T>
+// concept input_iterator;
 
-#include <set>
+#include <iterator>
 
 #include <concepts>
-#include <ranges>
 
-using range = std::multiset<int>;
-namespace stdr = std::ranges;
+// clang-format off
+template<std::input_or_output_iterator I>
+requires std::indirectly_readable<I> &&
+         std::derived_from<std::_ITER_CONCEPT<I>, std::input_iterator_tag>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return false;
+}
+
+template<std::input_iterator>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return true;
+}
+// clang-format on
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
+static_assert(check_subsumption<int*>());

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <vector>
 
 using iterator = std::back_insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(!std::weakly_incrementable<iterator>);
 static_assert(!std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
+static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <list>
 
 using iterator = std::front_insert_iterator<std::list<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(!std::weakly_incrementable<iterator>);
 static_assert(!std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
+static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <vector>
 
 using iterator = std::insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(!std::weakly_incrementable<iterator>);
 static_assert(!std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
+static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::move_iterator<int*>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, int>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
+static_assert(std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp

 
 using iterator = std::reverse_iterator<int*>;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
+static_assert(std::input_iterator<iterator>);
 
 using other_iterator = std::reverse_iterator<float*>;
 static_assert(std::sentinel_for<iterator, other_iterator>);

libcxx/test/std/iterators/stream.iterators/istream.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <iosfwd>
 
 using iterator = std::istream_iterator<int, std::istream>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, int>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
+static_assert(std::input_iterator<iterator>);

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

 
 using iterator = std::istreambuf_iterator<char>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
 static_assert(std::weakly_incrementable<iterator>);
 static_assert(!std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
+static_assert(std::input_iterator<iterator>);

libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <iosfwd>
 
 using iterator = std::ostream_iterator<int, std::ostream>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(!std::weakly_incrementable<iterator>);
 static_assert(!std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
+static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <string>
 
 using iterator = std::ostreambuf_iterator<char>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, char>);
 static_assert(!std::weakly_incrementable<iterator>);
 static_assert(!std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
+static_assert(!std::input_iterator<iterator>);

libcxx/test/std/ranges/range.refinements/input_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
+
+// template<range _Rp>
+// concept input_range;
+
+#include <ranges>
+
+#include "test_range.h"
+
+namespace stdr = std::ranges;
+
+static_assert(stdr::input_range<test_range<input_iterator> >);
+static_assert(stdr::input_range<test_range<input_iterator> const>);
+
+static_assert(stdr::input_range<test_range<cxx20_input_iterator> >);
+static_assert(stdr::input_range<test_range<cxx20_input_iterator> const>);
+
+static_assert(stdr::input_range<test_non_const_range<input_iterator> >);
+static_assert(stdr::input_range<test_non_const_range<cxx20_input_iterator> >);
+
+static_assert(!stdr::input_range<test_non_const_range<input_iterator> const>);
+static_assert(!stdr::input_range<test_non_const_range<cxx20_input_iterator> const>);
+
+static_assert(stdr::input_range<test_common_range<input_iterator> >);
+static_assert(!stdr::input_range<test_common_range<cxx20_input_iterator> >);
+
+static_assert(stdr::input_range<test_common_range<input_iterator> const>);
+static_assert(!stdr::input_range<test_common_range<cxx20_input_iterator> const>);
+
+static_assert(stdr::input_range<test_non_const_common_range<input_iterator> >);
+static_assert(!stdr::input_range<test_non_const_common_range<cxx20_input_iterator> >);
+
+static_assert(!stdr::input_range<test_non_const_common_range<input_iterator> const>);
+static_assert(!stdr::input_range<test_non_const_common_range<cxx20_input_iterator> const>);

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
 
-// reverse_iterator
+// template<class T>
+// concept input_iterator;
 
-#include <iterator>
+#include <ranges>
 
-using iterator = std::reverse_iterator<int*>;
+#include <iterator>
 
-static_assert(std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, int>);
-static_assert(std::incrementable<iterator>);
-static_assert(std::input_or_output_iterator<iterator>);
-static_assert(std::sentinel_for<iterator, 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
 
-using other_iterator = std::reverse_iterator<float*>;
-static_assert(std::sentinel_for<iterator, other_iterator>);
+static_assert(check_input_range_subsumption<range>());

libcxx/test/std/re/re.iter/re.regiter/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::cregex_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_iterator, char>);
 static_assert(std::incrementable<std::cregex_iterator>);
 static_assert(std::input_or_output_iterator<std::cregex_iterator>);
 static_assert(std::sentinel_for<std::cregex_iterator, std::cregex_iterator>);
+static_assert(std::input_iterator<std::cregex_iterator>);

libcxx/test/std/re/re.iter/re.tokiter/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::cregex_token_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_token_iterator, char>);
 static_assert(std::incrementable<std::cregex_token_iterator>);
 static_assert(std::input_or_output_iterator<std::cregex_token_iterator>);
 static_assert(std::sentinel_for<std::cregex_token_iterator, std::cregex_token_iterator>);
+static_assert(std::input_iterator<std::cregex_token_iterator>);

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(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>);

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(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>);

libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

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(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>);

libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, char>);
 static_assert(std::incrementable<const_iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::input_iterator<const_iterator>);

libcxx/test/support/test_iterators.h

 template <typename T>
 bool operator== (const NonThrowingIterator<T>& a, const NonThrowingIterator<T>& b) TEST_NOEXCEPT
 {   return a.operator==(b); }
 
 template <typename T>
 bool operator!= (const NonThrowingIterator<T>& a, const NonThrowingIterator<T>& b) TEST_NOEXCEPT
 {   return !a.operator==(b); }
 
+#ifdef TEST_SUPPORTS_RANGES
+
+template <class I>
+struct cxx20_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;
+
+  cxx20_input_iterator() = default;
+
+  cxx20_input_iterator(cxx20_input_iterator&&) = default;
+  cxx20_input_iterator& operator=(cxx20_input_iterator&&) = default;
+
+  cxx20_input_iterator(cxx20_input_iterator const&) = delete;
+  cxx20_input_iterator& operator=(cxx20_input_iterator const&) = delete;
+
+  explicit constexpr cxx20_input_iterator(I base) : base_(std::move(base)) {}
+
+  constexpr decltype(auto) operator*() const { return *base_; }
+
+  cxx20_input_iterator& operator++() {
+    ++base_;
+    return *this;
+  }
+
+  void operator++(int) { ++base_; }
+
+  [[nodiscard]] I const& base() const& { return base_; }
+
+  [[nodiscard]] I base() && { return std::move(base_); }
+
+private:
+  I base_ = I();
+};
+
+#endif // TEST_STD_VER > 17 && defined(__cpp_lib_concepts)
+
 #undef DELETE_FUNCTION
 
 #endif // ITERATORS_H

libcxx/test/support/test_macros.h

 #else
 #define LIBCPP_ASSERT(...) ((void)0)
 #define LIBCPP_STATIC_ASSERT(...) ((void)0)
 #define LIBCPP_ASSERT_NOEXCEPT(...) ((void)0)
 #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ((void)0)
 #define LIBCPP_ONLY(...) ((void)0)
 #endif
 
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+#define TEST_SUPPORTS_RANGES
+#endif
+
 #define TEST_IGNORE_NODISCARD (void)
 
 namespace test_macros_detail {
 template <class T, class U>
 struct is_same { enum { value = 0};} ;
 template <class T>
 struct is_same<T, T> { enum {value = 1}; };
 } // namespace test_macros_detail

libcxx/test/support/test_range.h

 
 #include "test_iterators.h"
 
 #ifdef _LIBCPP_HAS_NO_RANGES
 #error "test/suppoort/test_range.h" can only be included in builds supporting ranges
 #endif
 
 struct sentinel {
-  bool operator==(std::input_or_output_iterator auto) const;
+  bool operator==(std::input_or_output_iterator auto const&) const;
 };
 
 // clang-format off
 template <template <class...> class I = input_iterator>
 requires std::input_or_output_iterator<I<int*> >
 struct test_range {
   I<int*> begin();
   I<int const*> begin() const;