[libc++][ranges] P2116R9: Implements `views::enumerate`

[H-G-Hristov]

Summary

Implements P2116R9 views::enumerate

https://wg21.link/P2164R9
https://wg21.link/range.enumerate / https://eel.is/c++draft/range.enumerate

[H-G-Hristov]

Rebased + added iterator base test

[H-G-Hristov]

Added three way compare test

[H-G-Hristov]

Rebased + cleanup compare.three_way test

[H-G-Hristov]

Rebased + cleanup

[Mordante]

Thanks for working on this!
I mainly glossed over the patch and didn't do a real review. Just a few comments.

libcxx/include/__ranges/concepts.h

151 ↗

(On Diff #551923)

This is already implied by the __uglified name. The same at other places.

libcxx/include/__ranges/enumerate_view.h

65

Can you test whether this helps clang-format to do slightly better?

[Zingam]

Just a note to me. Adjust modules according to this: https://reviews.llvm.org/D158358

[H-G-Hristov]

Addressed some comments

[H-G-Hristov]

Thank you for the comments!

libcxx/include/__ranges/enumerate_view.h

65

It doesn't make a difference. I don't like how requires is snapped to the brackets () but I'll add it for consistency with the rest of the code.
I don't think that clang-format did that bad. Where else will = default or {} go without making it even less readable?

[H-G-Hristov]

Addressed more comments

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Rebased

[var-const]

Thank you for the patch! All in all it looks pretty good already. I have only started going through tests but wanted to share the feedback I already have.

libcxx/docs/Status/Cxx2cIssues.csv

12

IMO this should be Complete as well (I think Nothing To Do is for things like semantic requirements that are not enforceable in code).

libcxx/docs/Status/RangesViews.csv

38

Nit: please add a link to the patch (replacing the No patch yet part).

libcxx/include/__ranges/concepts.h

146 ↗

(On Diff #556109)

Do we need this annotation? Where is it coming from?

149 ↗

(On Diff #556109)

Since it's only used in enumerate_view, I would move the concept to that header (that's what we do for other view-specific concepts).

libcxx/include/__ranges/enumerate_view.h

49

Nit: I don't think the , class template enumerate_view::iterator part adds much value, it just restates the declaration that immediately follows. I'd remove the whole comment, but if you'd prefer to keep it, then let's keep just the section name.

57

Rather than making this public, can we use friends?

153

Do we need to move __pos (IIUC, it's always an integral type)?

161

Nit: extraneous semicolon.

305

Optional: rather than turning off clang-format, you could use comments to force the text to align (the upside is not having to manually do or maintain other aspects of formatting). E.g. as_rvalue_view does this:

template <class _Range>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
    noexcept(noexcept(/**/ as_rvalue_view(std::forward<_Range>(__range))))
        -> decltype(/*--*/ as_rvalue_view(std::forward<_Range>(__range))) {
  return /*-------------*/ as_rvalue_view(std::forward<_Range>(__range));

libcxx/include/ranges

320

I think we need to remove the freestanding comments since we don't implement freestanding yet.

libcxx/test/std/ranges/range.adaptors/range.enumerate/adaptor.pass.cpp

34–36

Nit: formatting around here looks a little surprising.

41

Can this just be a call to ranges::equal?

76

Nit: please add a blank line after this line.

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

31

Nit: can we add a test case that uses a non-const view (without moving)?

36

Nit: please add a blank line between different test cases. Applies throughout the patch.

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

17

Nit: this comment should contain just the function declaration, without the definition. Applies throughout.

30

Can we check both the case of iterator<false> and of iterator<true>?

36

Nit: I think we've been moving away from using ASSERT_SAME_TYPE towards just doing a static_assert directly.

55

Ultranit: s/a/an/.

libcxx/test/std/ranges/range.adaptors/range.enumerate/enable_borrowed_range.compile.pass.cpp

17

Nit: please remove the freestanding bit (throughout).

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

44

We also need to check the case where end returns a sentinel, and both the const and non-const cases.

46

s/begin/end/.

51

Should be .end().

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

19

Does this need to be a view? If it does, then I think it should be named View and not just Range.

39

When accessing internal types, we need to use _LIBCPP_STATIC_ASSERT. That macro is a no-op when tests are run by other implementations (e.g. MSVC) -- our test suite is used by other implementations as well.

42

Can we static_assert that this class satisfies sized_range?

[H-G-Hristov]

Addressed some comments

[H-G-Hristov]

In D157193#4642507, @var-const wrote:

Thank you for the patch! All in all it looks pretty good already. I have only started going through tests but wanted to share the feedback I already have.

Thank you for the review!

[H-G-Hristov]

Addressed more review comments + added a missing test

[H-G-Hristov]

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/equal.pass.cpp

25

It looks like I forgot to add the this test.

[H-G-Hristov]

Addressed more review comments

[H-G-Hristov]

Added operator== test

[H-G-Hristov]

Addressed a couple of comments

[var-const]

Finished going through the tests -- some more feedback!

libcxx/test/std/ranges/range.adaptors/range.enumerate/sentinel/equal.pass.cpp

49

It should be possible to use types::for_each to cut down on the boilerplate a little bit (from type_algorithms.h). Applies to other similar parts of the patch as well.

libcxx/test/std/ranges/range.adaptors/range.enumerate/sentinel/minus.pass.cpp

14

Nit: s/enumerate_view/enumerate_view::sentinel/?

86

Question: why does BufferView need to be a separate class? Can it be merged with Range?

94

Nit: missing include.

131

Can we also static_assert that Base is not a sized_range? (and vice versa below)

134

Optional nit: IMO it would be slightly easier to read if these were sorted, for example:

static_assert(!HasMinus<EnumerateIter<Base>, EnumerateSentinel<Base>>);
static_assert(!HasMinus<EnumerateIter<Base>, EnumerateConstSentinel<Base>>);
static_assert(!HasMinus<EnumerateConstIter<Base>, EnumerateSentinel<Base>>);
static_assert(!HasMinus<EnumerateConstIter<Base>, EnumerateConstSentinel<Base>>);

static_assert(!HasMinus<EnumerateSentinel<Base>, EnumerateIter<Base>>);
static_assert(!HasMinus<EnumerateSentinel<Base>, EnumerateConstIter<Base>>);
static_assert(!HasMinus<EnumerateConstSentinel<Base>, EnumerateIter<Base>>);
static_assert(!HasMinus<EnumerateConstSentinel<Base>, EnumerateConstIter<Base>>);

(below as well)

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

16

Nit: please add a semicolon at the end (so that it looks like a declaration)?

// constexpr auto size() requires sized_range<V>;

29

Can we check with a (pathological) type that is sized if it's non-const but not sized if it's const?

[var-const]

libcxx/include/__ranges/enumerate_view.h

52

Are we testing this constraint? (sorry if I missed it)

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

2

Note: you might also need to add the new view to libcxx/test/std/ranges/iterator_robust_against_adl.compile.pass.cpp.

libcxx/test/std/ranges/range.adaptors/range.enumerate/ctor.base.pass.cpp

62

This seems to be testing the default constructor?

74

Nit: please add a blank line after this line to separate the test cases.

libcxx/test/std/ranges/range.adaptors/range.enumerate/ctor.default.pass.cpp

36

Nit: it seems like this view can be merged with DefaultConstructibleView and NoDefaultView can be removed altogether.

45

Nit: s/NoDefaultView/NoDefaultCtrView/?

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/arithmetic.pass.cpp

79

Optional: I think it can be just {ts, ts + 5}.

82

Nit: add a comma?

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

16

Is this the right synopsis?

54

Can we check that the iterator was moved?

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/compare.three_way.pass.cpp

62

Nit: I don't think this check (and the helper concept) is necessary -- there are no constraints, and the compiler will complain when we try to call operator<=> anyway were it somehow not available.

79

Can we also have a similar check (but presumably evaluating to true) in the test case above?

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/ctor.convert.pass.cpp

2

We also need a types.pass.cpp or similar test file to check iterator_concept, iterator_category and other nested types of the iterator.

17

Can we check the convertible_to constraint?

51

Hmm, this seems to test operator++?

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/deref.pass.cpp

43

Note: some tests rely on CTAD when initializing std::array and some pass the template arguments explicitly. Can this be made consistent across the patch? (I would slightly prefer relying on CTAD to avoid explicitly specifying the size, but either is fine)

48

Can we also check with a const iterator?

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/equal.pass.cpp

16

Can we check the noexcept part?

36

Can we also check reverse argument order for each case, and increment it1 until it equals it2 and check that?

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/index.pass.cpp

44

Let's also check the return type and noexcept, and make sure we can call index() on a const iterator.

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/iter_move.pass.cpp

18

I don't think we're checking the is_nothrow_move_constructible_v constraint?

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/subscript.pass.cpp

48

Can you add a quick comment to explain why we can't use assert(it[0] == *it); here instead of std::get?

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

34

Nit: we only use this function once, consider inlining it.

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

17

Can we check the convertible_to constraint?

48

s/sResult/sBase/?

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

16

The synopsis is for iterator, not sentinel.

24

IMO we should either test with other sentinel types or not make Sentinel a template parameter (throughout).

33

Question: why are so many calls to base necessary?

libcxx/test/std/ranges/range.adaptors/range.enumerate/sentinel/equal.pass.cpp

17

Is it possible to also check the OtherConst case?

42

Can we check s == it and s != it as well?

[var-const]

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

61

Nit: from the names, it's not obvious what is the difference between Range (which is also a view), JustAView and MinimalView. I understand that Range has some additional testing utilities (perhaps rename it to TestView? Not a great name, but perhaps just a little more descriptive). Can you explain a bit how JustAView and MinimalView differ in case it helps us come up with some more descriptive names?

75

static_assert(!std::invocable<NotInvocable>);?

99

Optional nit: in general, I'd suggest having one static_assert per check (so that should it fire, it's more obvious which exact check failed).

102

Optional nit: the class name makes it sound like it's always noexcept. Perhaps something like MaybeNoexceptIterMoveInputIterator?

[H-G-Hristov]

In D157193#4644531, @var-const wrote:

Finished going through the tests -- some more feedback!

@var-const Thank you for the review!

[ldionne]

@H-G-Hristov Hi, do you need any help to make progress on this? We're trying to clear up our Phabricator review queue and it would be great to land this :-)

[H-G-Hristov]

In D157193#4653711, @ldionne wrote:

@H-G-Hristov Hi, do you need any help to make progress on this? We're trying to clear up our Phabricator review queue and it would be great to land this :-)

@ldionne I'm sorry for the delayed answer. I don't mind if any one better than me takes over to complete this patch otherwise I'll try to update the patch before the end of the month. I'll definitely need some help with a few a the comments though.
I also have this patch here: https://reviews.llvm.org/D150525 and I am not sure how to implement the NullablePointer requirement as requested in the review.

[H-G-Hristov]

Rebased + addressed a few comments

[H-G-Hristov]

Addressed a few more comments

[H-G-Hristov]

Addressed some more comments

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

54

@var-const I'm not sure how to check if the iterator moved. I don't seem to find an example. Could you please give me a hint.

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/subscript.pass.cpp

48

I guess I wanted to be explicit. I undid that.

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Try to fix CI

[H-G-Hristov]

Added types.compile.pass.cpp

[H-G-Hristov]

Rebased + Try to upload changes again

[H-G-Hristov]

Renamed Range

[H-G-Hristov]

Rebased

[H-G-Hristov]

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

19

I think I got the inspiration for the name Range from other tests. I renamed it to RangeView and derivatives. Please let me know if it better like that.

61

Renamed to MinimalDefaultConstructedView. MinimalView requires a more sophisticated initializations which isn't needed for some tests.
Is it better like that?

[H-G-Hristov]

Addressed more comments

[H-G-Hristov]

Addressed some more comments

[H-G-Hristov]

Addressed more comments

[H-G-Hristov]

Updated test

libcxx/include/__ranges/enumerate_view.h

52

I added some tests to adaptor.pass.cpp. I am not entirely sure if it covers it all. Please let me know if it's sufficient.

[H-G-Hristov]

Added base.pass test

[H-G-Hristov]

Addressed comment

[H-G-Hristov]

libcxx/test/std/ranges/range.adaptors/range.enumerate/sentinel/equal.pass.cpp

49

All other tests in ranges use this pattern. I fails to see how types::for_each will improve readability. Anyway I can do it if you prefer the tests to use types::for_each.

[H-G-Hristov]

Addressed some comments

[H-G-Hristov]

Migrated to GitHub
https://github.com/llvm/llvm-project/pull/73617

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_print``                                 *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_as_rvalue``                      ``202207L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                          *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk_by``                       ``202202L``
     --------------------------------------------------- -----------------
+    ``__cpp_lib_ranges_enumerate``                      ``202302L``
+    --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_iota``                           *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_join_with``                      *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_repeat``                         ``202207L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_ranges_slide``                          *unimplemented*
     --------------------------------------------------- -----------------

libcxx/docs/Status/Cxx23Papers.csv

 "`P2396R1 <https://wg21.link/P2396R1>`__","LWG", "Concurrency TS 2 fixes ", "November 2022","","","|concurrency TS|"
 "`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","|Complete|","17.0",""
 "`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","|In Progress|","","|format|"
 "`P2602R2 <https://wg21.link/P2602R2>`__","LWG", "Poison Pills are Too Toxic", "November 2022","","","|ranges|"
 "`P2708R1 <https://wg21.link/P2708R1>`__","LWG", "No Further Fundamentals TSes", "November 2022","|Nothing to do|","",""
 "","","","","","",""
 "`P0290R4 <https://wg21.link/P0290R4>`__","LWG", "``apply()`` for ``synchronized_value<T>``","February 2023","","","|concurrency TS|"
 "`P2770R0 <https://wg21.link/P2770R0>`__","LWG", "Stashing stashing ``iterators`` for proper flattening","February 2023","|In Progress|","","|ranges|"
-"`P2164R9 <https://wg21.link/P2164R9>`__","LWG", "``views::enumerate``","February 2023","","","|ranges|"
+"`P2164R9 <https://wg21.link/P2164R9>`__","LWG", "``views::enumerate``","February 2023","|Complete|","18.0","|ranges|"
 "`P2711R1 <https://wg21.link/P2711R1>`__","LWG", "Making multi-param constructors of ``views`` ``explicit``","February 2023","|In Progress| [#note-P2711R1]_","","|ranges|"
 "`P2609R3 <https://wg21.link/P2609R3>`__","LWG", "Relaxing Ranges Just A Smidge","February 2023","","","|ranges|"
 "`P2713R1 <https://wg21.link/P2713R1>`__","LWG", "Escaping improvements in ``std::format``","February 2023","","","|format|"
 "`P2675R1 <https://wg21.link/P2675R1>`__","LWG", "``format``'s width estimation is too approximate and not forward compatible","February 2023","|Complete|","17.0","|format|"
 "`P2572R1 <https://wg21.link/P2572R1>`__","LWG", "``std::format`` fill character allowances","February 2023","|Complete|","17.0","|format|"
 "`P2693R1 <https://wg21.link/P2693R1>`__","LWG", "Formatting ``thread::id`` and ``stacktrace``","February 2023","|Partial| [#note-P2693R1]_","","|format|"
 "`P2679R2 <https://wg21.link/P2679R2>`__","LWG", "Fixing ``std::start_lifetime_as`` for arrays","February 2023","","",""
 "`P2674R1 <https://wg21.link/P2674R1>`__","LWG", "A trait for implicit lifetime types","February 2023","","",""
 "`P2655R3 <https://wg21.link/P2655R3>`__","LWG", "``common_reference_t`` of ``reference_wrapper`` Should Be a Reference Type","February 2023","","",""
 "`P2652R2 <https://wg21.link/P2652R2>`__","LWG", "Disallow User Specialization of ``allocator_traits``","February 2023","","",""
 "`P2787R1 <https://wg21.link/P2787R1>`__","LWG", "``pmr::generator`` - Promise Types are not Values","February 2023","","",""
 "`P2614R2 <https://wg21.link/P2614R2>`__","LWG", "Deprecate ``numeric_limits::has_denorm``","February 2023","|Complete|","18.0",""
 "`P2588R3 <https://wg21.link/P2588R3>`__","LWG", "``barrier``’s phase completion guarantees","February 2023","","",""
 "`P2763R1 <https://wg21.link/P2763R1>`__","LWG", "``layout_stride`` static extents default constructor fix","February 2023","","",""
 "`P2736R2 <https://wg21.link/P2736R2>`__","CWG","Referencing The Unicode Standard","February 2023","","","|format|"

libcxx/docs/Status/Cxx2cIssues.csv

 "Issue #","Issue Name","Meeting","Status","First released version","Labels"
 "`2994 <https://wg21.link/LWG2994>`__","Needless UB for ``basic_string`` and ``basic_string_view``","Varna June 2023","|Complete|","5.0",""
 "`3884 <https://wg21.link/LWG3884>`__","``flat_foo`` is missing allocator-extended copy/move constructors","Varna June 2023","","","|flat_containers|"
 "`3885 <https://wg21.link/LWG3885>`__","``op`` should be in [zombie.names]","Varna June 2023","|Nothing To Do|","",""
 "`3887 <https://wg21.link/LWG3887>`__","Version macro for ``allocate_at_least``","Varna June 2023","","",""
 "`3893 <https://wg21.link/LWG3893>`__","LWG 3661 broke ``atomic<shared_ptr<T>> a; a = nullptr;``","Varna June 2023","","",""
 "`3894 <https://wg21.link/LWG3894>`__","``generator::promise_type::yield_value(ranges::elements_of<Rng, Alloc>)`` should not be ``noexcept``","Varna June 2023","","",""
 "`3903 <https://wg21.link/LWG3903>`__","span destructor is redundantly noexcept","Varna June 2023","|Complete|","7.0",""
 "`3904 <https://wg21.link/LWG3904>`__","``lazy_split_view::outer-iterator``'s const-converting constructor isn't setting ``trailing_empty_``","Varna June 2023","","","|ranges|"
 "`3905 <https://wg21.link/LWG3905>`__","Type of ``std::fexcept_t``","Varna June 2023","|Complete|","3.4",""
-"`3912 <https://wg21.link/LWG3912>`__","``enumerate_view::iterator::operator-`` should be ``noexcept``","Varna June 2023","","","|ranges|"
-"`3914 <https://wg21.link/LWG3914>`__","Inconsistent template-head of ``ranges::enumerate_view``","Varna June 2023","","","|ranges|"
+"`3912 <https://wg21.link/LWG3912>`__","``enumerate_view::iterator::operator-`` should be ``noexcept``","Varna June 2023","|Complete|","18.0","|ranges|"
+"`3914 <https://wg21.link/LWG3914>`__","Inconsistent template-head of ``ranges::enumerate_view``","Varna June 2023","|Complete|","18.0","|ranges|"
 "`3915 <https://wg21.link/LWG3915>`__","Redundant paragraph about expression variations","Varna June 2023","","","|ranges|"
 "`3925 <https://wg21.link/LWG3925>`__","Concept ``formattable``'s definition is incorrect","Varna June 2023","|Complete|","17.0","|format|"
 "`3927 <https://wg21.link/LWG3927>`__","Unclear preconditions for ``operator[]`` for sequence containers","Varna June 2023","|Nothing To Do|","",""
 "`3935 <https://wg21.link/LWG3935>`__","``template<class X> constexpr complex& operator=(const complex<X>&)`` has no specification","Varna June 2023","|Complete|","3.4",""
 "`3938 <https://wg21.link/LWG3938>`__","Cannot use ``std::expected`` monadic ops with move-only ``error_type``","Varna June 2023","|Complete|","18.0",""
 "`3940 <https://wg21.link/LWG3940>`__","``std::expected<void, E>::value()`` also needs ``E`` to be copy constructible","Varna June 2023","","",""
 "","","","","",""
 "`3343 <https://wg21.link/LWG3343>`__","Ordering of calls to ``unlock()`` and ``notify_all()`` in Effects element of ``notify_all_at_thread_exit()`` should be reversed","Not Yet Adopted","|Complete|","16.0",""
 "`3892 <https://wg21.link/LWG3892>`__","Incorrect formatting of nested ranges and tuples","Not Yet Adopted","|Complete|","17.0","|format|"
 "","","","","",""

libcxx/docs/Status/RangesViews.csv

 C++23,`adjacent_transform <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`join_with <https://wg21.link/P2441R2>`_,Jakub Mazurkiewicz,`65536 <https://github.com/llvm/llvm-project/pull/65536>`_,In progress
 C++23,`slide <https://wg21.link/P2442R1>`_,Will Hawkins,`67146 <https://github.com/llvm/llvm-project/pull/67146>`_,In Progress
 C++23,`chunk <https://wg21.link/P2442R1>`_,Unassigned,No patch yet,Not started
 C++23,`chunk_by <https://wg21.link/P2443R1>`_,Jakub Mazurkiewicz,`D144767 <https://llvm.org/D144767>`_,✅
 C++23,`as_const <https://wg21.link/P2278R4>`_,Unassigned,No patch yet,Not started
 C++23,`as_rvalue <https://wg21.link/P2446R2>`_,Nikolas Klauser,`D137637 <https://llvm.org/D137637>`_,✅
 C++23,`stride <https://wg21.link/P1899R3>`_,Hristo Hristov and Will Hawkins,`D156924 <https://llvm.org/D156924>`_,In Progress
-C++23,`enumerate <https://wg21.link/P2164R9>`_,Hristo Hristov,`D157193 <https://reviews.llvm.org/D157193>`_,In Progress
+C++23,`enumerate <https://wg21.link/P2164R9>`_,Hristo Hristov,`D157193 <https://reviews.llvm.org/D157193>`_,✅

libcxx/include/CMakeLists.txt

set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/drop_while_view.h
   __ranges/elements_view.h
   __ranges/empty.h
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
+  __ranges/enumerate_view.h
   __ranges/filter_view.h
   __ranges/from_range.h
   __ranges/iota_view.h
   __ranges/istream_view.h
   __ranges/join_view.h
   __ranges/lazy_split_view.h
   __ranges/movable_box.h
   __ranges/non_propagating_cache.h

libcxx/include/__ranges/enumerate_view.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_ENUMERATE_VIEW_H
+#define _LIBCPP___RANGES_ENUMERATE_VIEW_H
+
+#include <__concepts/convertible_to.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/distance.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/maybe_const.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+// [concept.object]
+
+template <class _Rp>
+concept __range_with_movable_references =
+    ranges::input_range<_Rp> && std::move_constructible<ranges::range_reference_t<_Rp>> &&
+    std::move_constructible<ranges::range_rvalue_reference_t<_Rp>>;
+
+// [range.enumerate.view]
+
+template <view _View>
+  requires __range_with_movable_references<_View>
+class enumerate_view : public view_interface<enumerate_view<_View>> {
+  _View __base_ = _View();
+
+  // [range.enumerate.iterator]
+  template <bool _Const>
+  class __iterator;
+
+  // [range.enumerate.sentinel]
+  template <bool _Const>
+  class __sentinel;
+
+  template <bool _AnyConst>
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __get_current(const __iterator<_AnyConst>& __iter) {
+    return (__iter.__current_);
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr enumerate_view()
+    requires(default_initializable<_View>)
+  = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit enumerate_view(_View __base) : __base_(std::move(__base)){};
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!__simple_view<_View>)
+  {
+    return __iterator<false>(ranges::begin(__base_), 0);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires __range_with_movable_references<const _View>
+  {
+    return __iterator<true>(ranges::begin(__base_), 0);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
+    if constexpr (common_range<_View> && sized_range<_View>)
+      return __iterator<false>(ranges::end(__base_), ranges::distance(__base_));
+    else
+      return __sentinel<false>(ranges::end(__base_));
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires __range_with_movable_references<const _View>
+  {
+    if constexpr (common_range<const _View> && sized_range<const _View>)
+      return __iterator<true>(ranges::end(__base_), ranges::distance(__base_));
+    else
+      return __sentinel<true>(ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+};
+
+template <class _Range>
+enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
+
+// [range.enumerate.iterator]
+
+template <view _View>
+  requires __range_with_movable_references<_View>
+template <bool _Const>
+class enumerate_view<_View>::__iterator {
+  using _Base = __maybe_const<_Const, _View>;
+
+  static consteval auto __get_iterator_concept() {
+    if constexpr (random_access_range<_Base>) {
+      return random_access_iterator_tag{};
+    } else if constexpr (bidirectional_range<_Base>) {
+      return bidirectional_iterator_tag{};
+    } else if constexpr (forward_range<_Base>) {
+      return forward_iterator_tag{};
+    } else {
+      return input_iterator_tag{};
+    }
+  }
+
+  friend class enumerate_view<_View>;
+
+public:
+  using iterator_category = input_iterator_tag;
+  using iterator_concept  = decltype(__get_iterator_concept());
+  using difference_type   = range_difference_t<_Base>;
+  using value_type        = tuple<difference_type, range_value_t<_Base>>;
+
+private:
+  using __reference_type       = tuple<difference_type, range_reference_t<_Base>>;
+  iterator_t<_Base> __current_ = iterator_t<_Base>();
+  difference_type __pos_       = 0;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(iterator_t<_Base> __current, difference_type __pos)
+      : __current_(std::move(__current)), __pos_(__pos) {}
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __iterator()
+    requires(default_initializable<iterator_t<_Base>>)
+  = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
+    requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+      : __current_(std::move(__i.__current_)), __pos_(__i.__pos_) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const iterator_t<_Base>& base() const& noexcept { return __current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Base> base() && { return std::move(__current_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr difference_type index() const noexcept { return __pos_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator*() const { return __reference_type(__pos_, *__current_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    ++__current_;
+    ++__pos_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { return ++*this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires forward_range<_Base>
+  {
+    auto __temp = *this;
+    ++*this;
+    return __temp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires bidirectional_range<_Base>
+  {
+    --__current_;
+    --__pos_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires bidirectional_range<_Base>
+  {
+    auto __temp = *this;
+    --*this;
+    return *__temp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ += __n;
+    __pos_ += __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ -= __n;
+    __pos_ -= __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type __n) const
+    requires random_access_range<_Base>
+  {
+    return __reference_type(__pos_ + __n, __current_[__n]);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) noexcept {
+    return __x.__pos_ == __y.__pos_;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr strong_ordering
+  operator<=>(const __iterator& __x, const __iterator& __y) noexcept {
+    return __x.__pos_ <=> __y.__pos_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    auto __temp = __i;
+    __temp += __n;
+    return __temp;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
+    requires random_access_range<_Base>
+  {
+    return __i + __n;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    auto __temp = __i;
+    __temp -= __n;
+    return __temp;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
+  operator-(const __iterator& __x, const __iterator& __y) noexcept {
+    return __x.__pos_ - __y.__pos_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto iter_move(const __iterator& __i) noexcept(
+      noexcept(ranges::iter_move(__i.__current_)) && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>) {
+    return tuple<difference_type, range_rvalue_reference_t<_Base>>(__i.__pos_, ranges::iter_move(__i.__current_));
+  }
+};
+
+// [range.enumerate.sentinel]
+
+template <view _View>
+  requires __range_with_movable_references<_View>
+template <bool _Const>
+class enumerate_view<_View>::__sentinel {
+  using _Base              = __maybe_const<_Const, _View>;
+  sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
+
+  friend class enumerate_view<_View>;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __other)
+    requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+      : __end_(std::move(__other.__end_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
+
+  template <bool _OtherConst>
+    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __get_current(__x) == __y.__end_;
+  }
+
+  template <bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __get_current(__x) - __y.__end_;
+  }
+
+  template <bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
+    return __x.__end_ - __get_current(__y);
+  }
+};
+
+template <class _View>
+constexpr bool enable_borrowed_range<enumerate_view<_View>> = enable_borrowed_range<_View>;
+
+namespace views {
+namespace __enumerate {
+
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(/**/ enumerate_view(std::forward<_Range>(__range))))
+          -> decltype(/*--*/ enumerate_view(std::forward<_Range>(__range))) {
+    return /*-------------*/ enumerate_view(std::forward<_Range>(__range));
+  }
+};
+
+} // namespace __enumerate
+
+inline namespace __cpo {
+
+inline constexpr auto enumerate = __enumerate::__fn{};
+
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_ENUMERATE_VIEW_H

libcxx/include/module.modulemap.in

 module std_private_ranges_data                       [system] { header "__ranges/data.h" }
 module std_private_ranges_drop_view                  [system] { header "__ranges/drop_view.h" }
 module std_private_ranges_drop_while_view            [system] { header "__ranges/drop_while_view.h" }
 module std_private_ranges_elements_view              [system] { header "__ranges/elements_view.h" }
 module std_private_ranges_empty                      [system] { header "__ranges/empty.h" }
 module std_private_ranges_empty_view                 [system] { header "__ranges/empty_view.h" }
 module std_private_ranges_enable_borrowed_range      [system] { header "__ranges/enable_borrowed_range.h" }
 module std_private_ranges_enable_view                [system] { header "__ranges/enable_view.h" }
+module std_private_ranges_enumerate_view             [system] { header "__ranges/enumerate_view.h" }
 module std_private_ranges_filter_view                [system] {
   header "__ranges/filter_view.h"
   export std_private_ranges_range_adaptor
 }
 module std_private_ranges_from_range                 [system] { header "__ranges/from_range.h" }
 module std_private_ranges_iota_view                  [system] { header "__ranges/iota_view.h" }
 module std_private_ranges_istream_view               [system] {
   header "__ranges/istream_view.h"

libcxx/include/ranges

// [range.reverse], reverse view
   template<class Val>
     using istream_view = basic_istream_view<Val, char>;
 
   template<class Val>
     using wistream_view = basic_istream_view<Val, wchar_t>;
 
   namespace views { template<class T> inline constexpr unspecified istream = unspecified; }
 
+  // [range.enumerate], enumerate view
+  template<view View>
+    requires see below
+  class enumerate_view;                                                             // since C++23
+
+  template<class View>
+    constexpr bool enable_borrowed_range<enumerate_view<View>> =                    // since C++23
+      enable_borrowed_range<View>;
+
+  namespace views { inline constexpr unspecified enumerate = unspecified; }         // since C++23
+
   // [range.zip], zip view
   template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
   class zip_view;        // C++23
 
   template<class... Views>
     inline constexpr bool enable_borrowed_range<zip_view<Views...>> =       // C++23
       (enable_borrowed_range<Views> && ...);

 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/drop_while_view.h>
 #include <__ranges/elements_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
+#include <__ranges/enumerate_view.h>
 #include <__ranges/filter_view.h>
 #include <__ranges/from_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/lazy_split_view.h>
 #include <__ranges/rbegin.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/rend.h>

libcxx/include/version

 __cpp_lib_polymorphic_allocator                         201902L <memory_resource>
 __cpp_lib_print                                         202207L <ostream> <print>
 __cpp_lib_quoted_string_io                              201304L <iomanip>
 __cpp_lib_ranges                                        202207L <algorithm> <functional> <iterator>
                                                                 <memory> <ranges>
 __cpp_lib_ranges_as_rvalue                              202207L <ranges>
 __cpp_lib_ranges_chunk                                  202202L <ranges>
 __cpp_lib_ranges_chunk_by                               202202L <ranges>
+__cpp_lib_ranges_enumerate                              202302L <ranges>
 __cpp_lib_ranges_iota                                   202202L <numeric>
 __cpp_lib_ranges_join_with                              202202L <ranges>
 __cpp_lib_ranges_repeat                                 202207L <ranges>
 __cpp_lib_ranges_slide                                  202202L <ranges>
 __cpp_lib_ranges_starts_ends_with                       202106L <algorithm>
 __cpp_lib_ranges_to_container                           202202L <deque> <forward_list> <list>
                                                                 <map> <queue> <ranges>
                                                                 <set> <stack> <string>

 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
 // # define __cpp_lib_print                                202207L
 # define __cpp_lib_ranges_as_rvalue                     202207L
 // # define __cpp_lib_ranges_chunk                         202202L
 # define __cpp_lib_ranges_chunk_by                      202202L
+# define __cpp_lib_ranges_enumerate                     202302L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
 # define __cpp_lib_ranges_repeat                        202207L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
 # define __cpp_lib_ranges_to_container                  202202L
 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L

libcxx/modules/std/ranges.inc

 
 #if _LIBCPP_STD_VER >= 23
     // [range.chunk.by], chunk by view
     using std::ranges::chunk_by_view;
 
     namespace views {
       using std::ranges::views::chunk_by;
     }
-#endif // _LIBCPP_STD_VER >= 23
 
-#if 0
+#  if 0
     // [range.stride], stride view
     using std::ranges::stride_view;
 
     namespace views {
       using std::ranges::views::stride;
     }
 
     using std::ranges::cartesian_product_view;
 
     namespace views {
       using std::ranges::views::cartesian_product;
     }
-#endif
+#  endif
+
+    // [range.enumerate]
+    using std::ranges::enumerate_view;
+
+    namespace views {
+      using std::ranges::views::enumerate;
+    }
+#endif // _LIBCPP_STD_VER >= 23
   } // namespace ranges
 
   namespace views = ranges::views;
 
   using std::tuple_element;
   using std::tuple_size;
 
 #if _LIBCPP_STD_VER >= 23
   using std::from_range;
   using std::from_range_t;
 #endif // _LIBCPP_STD_VER >= 23
 } // namespace std

libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp

 
 // Test the feature test macros defined by <ranges>
 
 /*  Constant                         Value
     __cpp_lib_ranges                 202207L [C++20]
     __cpp_lib_ranges_as_rvalue       202207L [C++23]
     __cpp_lib_ranges_chunk           202202L [C++23]
     __cpp_lib_ranges_chunk_by        202202L [C++23]
+    __cpp_lib_ranges_enumerate       202302L [C++23]
     __cpp_lib_ranges_join_with       202202L [C++23]
     __cpp_lib_ranges_repeat          202207L [C++23]
     __cpp_lib_ranges_slide           202202L [C++23]
     __cpp_lib_ranges_to_container    202202L [C++23]
     __cpp_lib_ranges_zip             202110L [C++23]
 */
 
 #include <ranges>

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_repeat
 #   error "__cpp_lib_ranges_repeat should not be defined before c++23"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_repeat
 #   error "__cpp_lib_ranges_repeat should not be defined before c++23"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_repeat
 #   error "__cpp_lib_ranges_repeat should not be defined before c++23"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_repeat
 #   error "__cpp_lib_ranges_repeat should not be defined before c++23"
 # endif
 

 
 # ifndef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should be defined in c++23"
 # endif
 # if __cpp_lib_ranges_chunk_by != 202202L
 #   error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++23"
 # endif
 
+# ifndef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should be defined in c++23"
+# endif
+# if __cpp_lib_ranges_enumerate != 202302L
+#   error "__cpp_lib_ranges_enumerate should have the value 202302L in c++23"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_join_with
 #     error "__cpp_lib_ranges_join_with should be defined in c++23"
 #   endif
 #   if __cpp_lib_ranges_join_with != 202202L
 #     error "__cpp_lib_ranges_join_with should have the value 202202L in c++23"
 #   endif
 # else // _LIBCPP_VERSION

 
 # ifndef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should be defined in c++26"
 # endif
 # if __cpp_lib_ranges_chunk_by != 202202L
 #   error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++26"
 # endif
 
+# ifndef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should be defined in c++26"
+# endif
+# if __cpp_lib_ranges_enumerate != 202302L
+#   error "__cpp_lib_ranges_enumerate should have the value 202302L in c++26"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_join_with
 #     error "__cpp_lib_ranges_join_with should be defined in c++26"
 #   endif
 #   if __cpp_lib_ranges_join_with != 202202L
 #     error "__cpp_lib_ranges_join_with should have the value 202202L in c++26"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

/*  Constant                                         Value
     __cpp_lib_parallel_algorithm                     201603L [C++17]
     __cpp_lib_polymorphic_allocator                  201902L [C++20]
     __cpp_lib_print                                  202207L [C++23]
     __cpp_lib_quoted_string_io                       201304L [C++14]
     __cpp_lib_ranges                                 202207L [C++20]
     __cpp_lib_ranges_as_rvalue                       202207L [C++23]
     __cpp_lib_ranges_chunk                           202202L [C++23]
     __cpp_lib_ranges_chunk_by                        202202L [C++23]
+    __cpp_lib_ranges_enumerate                       202302L [C++23]
     __cpp_lib_ranges_iota                            202202L [C++23]
     __cpp_lib_ranges_join_with                       202202L [C++23]
     __cpp_lib_ranges_repeat                          202207L [C++23]
     __cpp_lib_ranges_slide                           202202L [C++23]
     __cpp_lib_ranges_starts_ends_with                202106L [C++23]
     __cpp_lib_ranges_to_container                    202202L [C++23]
     __cpp_lib_ranges_zip                             202110L [C++23]
     __cpp_lib_ratio                                  202306L [C++26]

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++23"
 # endif
 
+# ifdef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should not be defined before c++23"
+# endif
+
 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++23"
 # endif
 

 
 # ifndef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should be defined in c++23"
 # endif
 # if __cpp_lib_ranges_chunk_by != 202202L
 #   error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++23"
 # endif
 
+# ifndef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should be defined in c++23"
+# endif
+# if __cpp_lib_ranges_enumerate != 202302L
+#   error "__cpp_lib_ranges_enumerate should have the value 202302L in c++23"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_iota
 #     error "__cpp_lib_ranges_iota should be defined in c++23"
 #   endif
 #   if __cpp_lib_ranges_iota != 202202L
 #     error "__cpp_lib_ranges_iota should have the value 202202L in c++23"
 #   endif
 # else // _LIBCPP_VERSION

 
 # ifndef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should be defined in c++26"
 # endif
 # if __cpp_lib_ranges_chunk_by != 202202L
 #   error "__cpp_lib_ranges_chunk_by should have the value 202202L in c++26"
 # endif
 
+# ifndef __cpp_lib_ranges_enumerate
+#   error "__cpp_lib_ranges_enumerate should be defined in c++26"
+# endif
+# if __cpp_lib_ranges_enumerate != 202302L
+#   error "__cpp_lib_ranges_enumerate should have the value 202302L in c++26"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_iota
 #     error "__cpp_lib_ranges_iota should be defined in c++26"
 #   endif
 #   if __cpp_lib_ranges_iota != 202202L
 #     error "__cpp_lib_ranges_iota should have the value 202202L in c++26"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/test/std/ranges/iterator_robust_against_adl.compile.pass.cpp

using InnerRange =
     typename std::ranges::iterator_t<std::ranges::lazy_split_view<adl::BaseView, adl::BaseView>>::value_type;
 static_assert(!CanFindADLFunc<InnerRange >);
 
 static_assert(!CanFindADLFunc<std::ranges::split_view<adl::BaseView, adl::BaseView>>);
 static_assert(!CanFindADLFunc<std::ranges::transform_view<adl::BaseView, adl::Pred>>);
 
 #if TEST_STD_VER >= 23
 static_assert(!CanFindADLFunc<std::ranges::zip_view<adl::BaseView>>);
+static_assert(!CanFindADLFunc<std::ranges::enumerate_view<adl::BaseView>>);
 #endif

libcxx/test/std/ranges/range.adaptors/range.enumerate/adaptor.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// std::views::enumerate;
+
+#include <algorithm>
+#include <cassert>
+#include <ranges>
+#include <string_view>
+
+#include "types.h"
+
+// Concepts
+
+template <class View, class T>
+concept CanBePiped = requires(View&& view, T&& t) {
+  { std::forward<View>(view) | std::forward<T>(t) };
+};
+
+template <class Range>
+concept CanEnumerate = requires(Range&& range) { std::views::enumerate(std::forward<Range>(range)); };
+
+// Helpers
+
+struct ImmovableReference {
+  ImmovableReference(ImmovableReference&&) = delete;
+
+  operator int();
+};
+
+struct IteratorWithImmovableReferences {
+  using value_type      = int;
+  using difference_type = std::ptrdiff_t;
+
+  ImmovableReference operator*() const;
+  IteratorWithImmovableReferences& operator++();
+  void operator++(int);
+  bool operator==(std::default_sentinel_t) const;
+};
+
+static_assert(std::input_iterator<IteratorWithImmovableReferences>);
+
+using NonEnumeratableRangeWithImmmovabaleReferences =
+    std::ranges::subrange<IteratorWithImmovableReferences, std::default_sentinel_t>;
+
+static_assert(std::ranges::input_range<NonEnumeratableRangeWithImmmovabaleReferences>);
+static_assert(!CanEnumerate<NonEnumeratableRangeWithImmmovabaleReferences>);
+
+template <typename View, typename T>
+using ExpectedViewElement = std::tuple<typename std::ranges::iterator_t<View>::difference_type, T>;
+
+// Helpers
+
+template <typename View, typename T = int>
+constexpr void compareViews(View v, std::initializer_list<ExpectedViewElement<View, T>> list) {
+  assert(std::ranges::equal(v, list));
+}
+
+// Test SFINAE friendliness
+
+static_assert(CanBePiped<RangeView, decltype(std::views::enumerate)>);
+
+static_assert(CanEnumerate<RangeView>);
+
+static_assert(!std::is_invocable_v<decltype(std::views::enumerate)>);
+static_assert(std::is_invocable_v<decltype(std::views::enumerate), RangeView>);
+static_assert(!std::is_invocable_v<decltype(std::views::enumerate), NotAView>);
+static_assert(!std::is_invocable_v<decltype(std::views::enumerate), NotInvocable>);
+
+static_assert(std::is_same_v<decltype(std::ranges::views::enumerate), decltype(std::views::enumerate)>);
+
+constexpr bool test() {
+  // Test `views::enumerate_view(v)`
+  {
+    int buff[] = {0, 1, 2, 3};
+
+    using Result = std::ranges::enumerate_view<RangeView>;
+    RangeView const range(buff, buff + 4);
+
+    std::same_as<Result> decltype(auto) result = std::views::enumerate(range);
+    compareViews(result, {{0, 0}, {1, 1}, {2, 2}, {3, 3}});
+  }
+  {
+    std::string_view sv{"babazmt"};
+    using Result = std::ranges::enumerate_view<std::string_view>;
+
+    std::same_as<Result> decltype(auto) result = std::views::enumerate(sv);
+    compareViews(result, {{0, 'b'}, {1, 'a'}, {2, 'b'}, {3, 'a'}, {4, 'z'}, {5, 'm'}, {6, 't'}});
+  }
+
+  // Test `adaptor | views::enumerate`
+  {
+    int buff[] = {0, 1, 2, 3};
+
+    using Result = std::ranges::enumerate_view<RangeView>;
+    RangeView const range(buff, buff + 4);
+
+    std::same_as<Result> decltype(auto) result = range | std::views::enumerate;
+    compareViews(result, {{0, 0}, {1, 1}, {2, 2}, {3, 3}});
+  }
+  {
+    std::string_view sv{"babazmt"};
+    using Result = std::ranges::enumerate_view<std::string_view>;
+
+    std::same_as<Result> decltype(auto) result = sv | std::views::enumerate;
+    compareViews(result, {{0, 'b'}, {1, 'a'}, {2, 'b'}, {3, 'a'}, {4, 'z'}, {5, 'm'}, {6, 't'}});
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// constexpr V base() const & requires copy_constructible<V>;
+// constexpr V base() &&;
+
+#include <cassert>
+#include <ranges>
+
+#include "MoveOnly.h"
+#include "types.h"
+
+template <class T>
+concept HasBase = requires(T&& t) { std::forward<T>(t).base(); };
+
+// SFINAE
+
+static_assert(HasBase<std::ranges::enumerate_view<RangeView> const&>);
+static_assert(HasBase<std::ranges::enumerate_view<RangeView>&&>);
+
+struct MoveOnlyView : RangeView {
+  MoveOnly mo;
+};
+
+static_assert(!HasBase<std::ranges::enumerate_view<MoveOnlyView> const&>);
+static_assert(HasBase<std::ranges::enumerate_view<MoveOnlyView>&&>);
+
+constexpr bool test() {
+  // Check the const& overload
+  {
+    int buff[] = {0, 1, 2, 3};
+
+    RangeView range(buff, buff + 4);
+
+    std::ranges::enumerate_view<RangeView> view{range};
+    std::same_as<RangeView> decltype(auto) result = view.base();
+    assert(result.wasCopyInitialized);
+    assert(range.begin() == result.begin());
+    assert(range.end() == result.end());
+  }
+  {
+    int buff[] = {0, 1, 2, 3};
+
+    RangeView const range(buff, buff + 4);
+
+    std::ranges::enumerate_view<RangeView> const view{range};
+    std::same_as<RangeView> decltype(auto) result = view.base();
+    assert(result.wasCopyInitialized);
+    assert(range.begin() == result.begin());
+    assert(range.end() == result.end());
+  }
+
+  // Check the && overload
+  {
+    int buff[] = {0, 1, 2, 3};
+
+    RangeView const range(buff, buff + 4);
+
+    std::ranges::enumerate_view<RangeView> view{range};
+    std::same_as<RangeView> decltype(auto) result = std::move(view).base();
+    assert(result.wasMoveInitialized);
+    assert(range.begin() == result.begin());
+    assert(range.end() == result.end());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// constexpr auto begin() requires (!simple-view<V>);
+// constexpr auto begin() const requires range-with-movable-references<const V>;
+
+#include <cassert>
+#include <concepts>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "types.h"
+
+// Helpers
+
+template <class T>
+concept HasConstBegin = requires(const T ct) { ct.begin(); };
+
+template <class T>
+concept HasBegin = requires(T t) { t.begin(); };
+
+template <class T>
+concept HasConstAndNonConstBegin =
+    HasConstBegin<T> &&
+    // Because const begin() and non-const begin() returns different types: iterator<true> vs. iterator<false>
+    requires(T t, const T ct) { requires !std::same_as<decltype(t.begin()), decltype(ct.begin())>; };
+
+template <class T>
+concept HasOnlyNonConstBegin = HasBegin<T> && !HasConstBegin<T>;
+
+template <class T>
+concept HasOnlyConstBegin = HasConstBegin<T> && !HasConstAndNonConstBegin<T>;
+
+// Types
+
+template <bool Simple>
+struct CommonView : std::ranges::view_base {
+  constexpr std::tuple<std::ptrdiff_t, int>* begin()
+    requires(!Simple)
+  {
+    return nullptr;
+  }
+  constexpr const std::tuple<std::ptrdiff_t, int>* begin() const { return nullptr; }
+  constexpr std::tuple<std::ptrdiff_t, int>* end()
+    requires(!Simple)
+  {
+    return nullptr;
+  }
+  constexpr const std::tuple<std::ptrdiff_t, int>* end() const { return nullptr; }
+};
+using SimpleCommonView    = CommonView<true>;
+using NonSimpleCommonView = CommonView<false>;
+
+struct NoConstBeginView : std::ranges::view_base {
+  constexpr std::tuple<std::ptrdiff_t, int>* begin() { return nullptr; }
+  constexpr std::tuple<std::ptrdiff_t, int>* end() { return nullptr; }
+};
+
+// SFINAE
+
+// simple-view<V>
+static_assert(HasOnlyConstBegin<std::ranges::enumerate_view<SimpleCommonView>>);
+
+// !simple-view<V> && range<const V>
+static_assert(HasConstAndNonConstBegin<std::ranges::enumerate_view<NonSimpleCommonView>>);
+
+// !range<const V>
+static_assert(HasOnlyNonConstBegin<std::ranges::enumerate_view<NoConstBeginView>>);
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // Check the return type of begin()
+  {
+    RangeView range(buff, buff + 1);
+
+    std::ranges::enumerate_view view(range);
+    using Iterator = std::ranges::iterator_t<decltype(view)>;
+    static_assert(std::same_as<Iterator, decltype(view.begin())>);
+  }
+
+  // begin() over an empty range
+  {
+    RangeView range(buff, buff);
+
+    std::ranges::enumerate_view view(range);
+    auto it = view.begin();
+    assert(base(it.base()) == buff);
+    assert(it == view.end());
+  }
+
+  // begin() over an 1-element range
+  {
+    RangeView range(buff, buff + 1);
+
+    std::ranges::enumerate_view view(range);
+    auto it = view.begin();
+    assert(base(it.base()) == buff);
+  }
+
+  // begin() over an N-element range
+  {
+    RangeView range(buff, buff + 8);
+
+    std::ranges::enumerate_view view(range);
+    auto it = view.begin();
+    assert(base(it.base()) == buff);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// template<class R>
+//   enumerate_view(R&&) -> enumerate_view<views::all_t<R>>;
+
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "types.h"
+
+constexpr bool test() {
+  {
+    MinimalDefaultConstructedView jv;
+    std::ranges::enumerate_view view(jv);
+    static_assert(std::is_same_v<decltype(view), std::ranges::enumerate_view<MinimalDefaultConstructedView>>);
+  }
+
+  // Test with a range that isn't a view, to make sure we properly use views::all_t in the implementation.
+  {
+    NotAViewRange range;
+    std::ranges::enumerate_view view(range);
+    static_assert(std::is_same_v<decltype(view), std::ranges::enumerate_view<std::ranges::ref_view<NotAViewRange>>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/ctor.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// constexpr explicit enumerate_view(V base);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+
+#include "types.h"
+
+constexpr bool test() {
+  using EnumerateView = std::ranges::enumerate_view<RangeView>;
+
+  {
+    std::array base = {0, 1, 2, 3, 84};
+
+    RangeView range(base.begin(), base.end());
+    EnumerateView view{range};
+
+    auto baseIt = base.begin();
+    auto viewIt = view.begin();
+    for (std::size_t index = 0; index != base.size(); ++index) {
+      auto [vi, vv] = *viewIt;
+      assert(std::cmp_equal(index, vi));
+      assert(*baseIt == vv);
+
+      ++baseIt;
+      ++viewIt;
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// constexpr enumerate_view() requires default_initializable<V>;
+
+#include <ranges>
+
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+
+constexpr int buff[] = {0, 1};
+
+template <bool DefaultConstructible>
+struct DefaultConstructibleView : std::ranges::view_base {
+  constexpr DefaultConstructibleView()
+    requires DefaultConstructible
+      : begin_(buff), end_(buff + 1) {}
+
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+
+  int const* begin_;
+  int const* end_;
+};
+
+static_assert(std::is_default_constructible_v<std::ranges::enumerate_view<DefaultConstructibleView<true>>>);
+static_assert(!std::is_default_constructible_v<std::ranges::enumerate_view<DefaultConstructibleView<false>>>);
+
+constexpr bool test() {
+  using EnumerateView = std::ranges::enumerate_view<DefaultConstructibleView<true>>;
+
+  {
+    EnumerateView view;
+
+    assert((*view.begin() == std::tuple<std::ranges::iterator_t<EnumerateView>::difference_type, int>{0, 0}));
+    assert((*view.end() == std::tuple<std::ranges::iterator_t<EnumerateView>::difference_type, int>{1, 1}));
+
+    auto [bi, bv] = *view.begin();
+    assert(bi == 0);
+    assert(bv == 0);
+
+    auto [ei, ev] = *view.end();
+    assert(ei == 1);
+    assert(ev == 1);
+  }
+  {
+    EnumerateView view = {};
+
+    assert((*view.begin() == std::tuple<std::ranges::iterator_t<EnumerateView>::difference_type, int>{0, 0}));
+    assert((*view.end() == std::tuple<std::ranges::iterator_t<EnumerateView>::difference_type, int>{1, 1}));
+
+    auto [bi, bv] = *view.begin();
+    assert(bi == 0);
+    assert(bv == 0);
+
+    auto [ei, ev] = *view.end();
+    assert(ei == 1);
+    assert(ev == 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/enable_borrowed_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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// template<class View>
+//   constexpr bool enable_borrowed_range<enumerate_view<View>>;
+
+#include <cassert>
+#include <ranges>
+
+struct NonBorrowedRange : std::ranges::view_base {
+  int* begin();
+  int* end();
+};
+
+struct BorrowedRange : std::ranges::view_base {
+  int* begin();
+  int* end();
+};
+
+template <>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
+
+static_assert(!std::ranges::borrowed_range<std::ranges::enumerate_view<NonBorrowedRange>>);
+static_assert(std::ranges::borrowed_range<std::ranges::enumerate_view<BorrowedRange>>);

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// constexpr auto end() requires (!simple-view<V>);
+// constexpr auto end() const requires range-with-movable-references<const V>;
+
+#include <cassert>
+#include <concepts>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "types.h"
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // Check the return type of .end()
+  {
+    RangeView range(buff, buff + 1);
+
+    std::ranges::enumerate_view view(range);
+    using Iterator = std::ranges::iterator_t<decltype(view)>;
+    static_assert(std::same_as<Iterator, decltype(view.end())>);
+    using Sentinel = std::ranges::sentinel_t<decltype(view)>;
+    static_assert(std::same_as<Sentinel, decltype(view.end())>);
+  }
+
+  // Check the return type of .end() const
+  {
+    RangeView range(buff, buff + 1);
+
+    const std::ranges::enumerate_view view(range);
+    using Iterator = std::ranges::iterator_t<decltype(view)>;
+    static_assert(std::same_as<Iterator, decltype(view.end())>);
+    using Sentinel = std::ranges::sentinel_t<decltype(view)>;
+    static_assert(std::same_as<Sentinel, decltype(view.end())>);
+  }
+
+  // end() over an empty range
+  {
+    RangeView range(buff, buff);
+
+    std::ranges::enumerate_view view(range);
+
+    auto it = view.end();
+    assert(base(it.base()) == buff);
+    assert(it == view.end());
+
+    auto constIt = std::as_const(view).end();
+    assert(base(constIt.base()) == buff);
+    assert(constIt == std::as_const(view).end());
+  }
+
+  // end() const over an empty range
+  {
+    RangeView range(buff, buff);
+
+    const std::ranges::enumerate_view view(range);
+
+    auto it = view.end();
+    assert(base(it.base()) == buff);
+    assert(it == view.end());
+
+    auto constIt = std::as_const(view).end();
+    assert(base(constIt.base()) == buff);
+    assert(constIt == std::as_const(view).end());
+  }
+
+  // end() over an 1-element range
+  {
+    RangeView range(buff, buff + 1);
+
+    std::ranges::enumerate_view view(range);
+
+    auto it = view.end();
+    assert(base(it.base()) == buff + 1);
+
+    auto constIt = std::as_const(view).end();
+    assert(base(constIt.base()) == buff + 1);
+  }
+
+  // end() over an N-element range
+  {
+    RangeView range(buff, buff + 8);
+
+    std::ranges::enumerate_view view(range);
+
+    auto it = view.end();
+    assert(base(it.base()) == buff + 8);
+
+    auto constIt = std::as_const(view).end();
+    assert(base(constIt.base()) == buff + 8);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/arithmetic.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// constexpr iterator& operator+=(difference_type x)
+//   requires random_access_range<Base>;
+// constexpr iterator& operator-=(difference_type x)
+//   requires random_access_range<Base>;
+
+// friend constexpr iterator operator+(const iterator& x, difference_type y)
+//   requires random_access_range<Base>;
+// friend constexpr iterator operator+(difference_type x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr iterator operator-(const iterator& x, difference_type y)
+//   requires random_access_range<Base>;
+// friend constexpr difference_type operator-(const iterator& x, const iterator& y);
+
+#include <ranges>
+
+#include "test_iterators.h"
+
+// Concepts
+
+template <class T, class U>
+concept CanPlus = requires(T t, U u) { t + u; };
+
+template <class T, class U>
+concept CanPlusEqual = requires(T t, U u) { t += u; };
+
+template <class T, class U>
+concept CanMinus = requires(T t, U u) { t - u; };
+
+template <class T, class U>
+concept CanMinusEqual = requires(T t, U u) { t -= u; };
+
+template <class BaseRange>
+using EnumerateIter = std::ranges::iterator_t<std::ranges::enumerate_view<BaseRange>>;
+
+using RandomAccessRange = std::ranges::subrange<int*>;
+
+// SFINAE.
+
+static_assert(std::ranges::random_access_range<RandomAccessRange>);
+static_assert(
+    std::sized_sentinel_for<std::ranges::iterator_t<RandomAccessRange>, std::ranges::iterator_t<RandomAccessRange>>);
+
+static_assert(CanPlus<EnumerateIter<RandomAccessRange>, int>);
+static_assert(CanPlus<int, EnumerateIter<RandomAccessRange>>);
+static_assert(CanPlusEqual<EnumerateIter<RandomAccessRange>, int>);
+static_assert(CanMinus<EnumerateIter<RandomAccessRange>, int>);
+static_assert(CanMinus<EnumerateIter<RandomAccessRange>, EnumerateIter<RandomAccessRange>>);
+static_assert(CanMinusEqual<EnumerateIter<RandomAccessRange>, int>);
+
+using BidirectionalRange = std::ranges::subrange<bidirectional_iterator<int*>>;
+static_assert(!std::ranges::random_access_range<BidirectionalRange>);
+static_assert(
+    !std::sized_sentinel_for<std::ranges::iterator_t<BidirectionalRange>, std::ranges::iterator_t<BidirectionalRange>>);
+
+static_assert(!CanPlus<EnumerateIter<BidirectionalRange>, int>);
+static_assert(!CanPlus<int, EnumerateIter<BidirectionalRange>>);
+static_assert(!CanPlusEqual<EnumerateIter<BidirectionalRange>, int>);
+static_assert(!CanMinus<EnumerateIter<BidirectionalRange>, int>);
+static_assert(!CanMinusEqual<EnumerateIter<BidirectionalRange>, int>);
+
+constexpr bool test() {
+  int ts[] = {1, 2, 3, 4, 5};
+
+  RandomAccessRange r{ts, ts + 5};
+  auto ev = r | std::views::enumerate;
+
+  // operator+(x, n), operator+(n,x) and operator+=
+  {
+    auto it1 = ev.begin();
+
+    auto it2 = it1 + 3;
+    assert(it2.base() == &ts[3]);
+
+    auto it3 = 3 + it1;
+    assert(it3.base() == &ts[3]);
+
+    it1 += 3;
+    assert(it1 == it2);
+    assert(it1.base() == &ts[3]);
+  }
+
+  // operator-(x, n) and operator-=
+  {
+    auto it1 = ev.end();
+
+    auto it2 = it1 - 4;
+    assert(it2.base() == &ts[1]);
+
+    it1 -= 4;
+    assert(it1 == it2);
+    assert(it1.base() == &ts[1]);
+  }
+
+  // operator-(x, y)
+  {
+    assert((ev.end() - ev.begin()) == 5);
+
+    auto it1 = ev.begin() + 2;
+    auto it2 = ev.end() - 2;
+    assert((it1 - it2) == -1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// constexpr const iterator_t<Base>& base() const & noexcept;
+// constexpr iterator_t<Base> base() &&;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+#include <tuple>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator>
+constexpr void testBase() {
+  using Sentinel          = sentinel_wrapper<Iterator>;
+  using View              = MinimalView<Iterator, Sentinel>;
+  using EnumerateView     = std::ranges::enumerate_view<View>;
+  using EnumerateIterator = std::ranges::iterator_t<EnumerateView>;
+
+  auto make_enumerate_view = [](auto begin, auto end) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+
+    return EnumerateView(std::move(view));
+  };
+
+  std::array array{0, 1, 2, 3, 84};
+  const auto view = make_enumerate_view(array.begin(), array.end());
+
+  // Test the const& version
+  {
+    EnumerateIterator const it                          = view.begin();
+    std::same_as<const Iterator&> decltype(auto) result = it.base();
+    ASSERT_NOEXCEPT(it.base());
+    assert(base(result) == array.begin());
+  }
+
+  // Test the && version
+  {
+    EnumerateIterator it                         = view.begin();
+    std::same_as<Iterator> decltype(auto) result = std::move(it).base();
+    assert(base(result) == array.begin());
+  }
+}
+
+constexpr bool test() {
+  testBase<cpp17_input_iterator<int*>>();
+  testBase<cpp20_input_iterator<int*>>();
+  testBase<forward_iterator<int*>>();
+  testBase<bidirectional_iterator<int*>>();
+  testBase<random_access_iterator<int*>>();
+  testBase<contiguous_iterator<int*>>();
+  testBase<int*>();
+  testBase<int const*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/compare.three_way.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// friend constexpr strong_ordering operator<=>(const iterator& x, const iterator& y) noexcept;
+
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+constexpr void compareOperatorTest(const auto& iter1, const auto& iter2) {
+  assert(!(iter1 < iter1));
+  assert(iter1 < iter2);
+  assert(!(iter2 < iter1));
+
+  assert(iter1 <= iter1);
+  assert(iter1 <= iter2);
+  assert(!(iter2 <= iter1));
+
+  assert(!(iter1 > iter1));
+  assert(!(iter1 > iter2));
+  assert(iter2 > iter1);
+
+  assert(iter1 >= iter1);
+  assert(!(iter1 >= iter2));
+  assert(iter2 >= iter1);
+
+  assert(iter1 == iter1);
+  assert(!(iter1 == iter2));
+  assert(iter2 == iter2);
+
+  assert(!(iter1 != iter1));
+  assert(iter1 != iter2);
+  assert(!(iter2 != iter2));
+}
+
+constexpr bool test() {
+  int buff[] = {0, 1, 2, 3};
+  {
+    using View = std::ranges::enumerate_view<RangeView>;
+
+    using Iterator = std::ranges::iterator_t<View>;
+    static_assert(std::three_way_comparable<Iterator>);
+    using Subrange = std::ranges::subrange<Iterator>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<Subrange>>);
+    using EnumerateView = std::ranges::enumerate_view<Subrange>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<EnumerateView>>);
+
+    RangeView const range(buff, buff + 4);
+
+    std::same_as<View> decltype(auto) ev = std::views::enumerate(range);
+
+    auto it1 = ev.begin();
+    auto it2 = it1 + 1;
+
+    compareOperatorTest(it1, it2);
+
+    assert((it1 <=> it2) == std::strong_ordering::less);
+    assert((it1 <=> it1) == std::strong_ordering::equal);
+    assert((it2 <=> it2) == std::strong_ordering::equal);
+    assert((it2 <=> it1) == std::strong_ordering::greater);
+  }
+
+  // Test an old-school iterator with no operator<=>
+  {
+    using Iterator = random_access_iterator<int*>;
+    static_assert(!std::three_way_comparable<Iterator>);
+    using Subrange = std::ranges::subrange<Iterator>;
+    static_assert(!std::three_way_comparable<std::ranges::iterator_t<Subrange>>);
+    using EnumerateView = std::ranges::enumerate_view<Subrange>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<EnumerateView>>);
+
+    auto ev  = Subrange{Iterator{buff}, Iterator{buff + 3}} | std::views::enumerate;
+    auto it1 = ev.begin();
+    auto it2 = it1 + 1;
+
+    compareOperatorTest(it1, it2);
+
+    assert((it1 <=> it2) == std::strong_ordering::less);
+    assert((it1 <=> it1) == std::strong_ordering::equal);
+    assert((it2 <=> it2) == std::strong_ordering::equal);
+    assert((it2 <=> it1) == std::strong_ordering::greater);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/ctor.convert.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// constexpr iterator(iterator<!Const> i)
+//   requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View                   = MinimalView<Iterator, Sentinel>;
+  using EnumerateView          = std::ranges::enumerate_view<View>;
+  using EnumerateIterator      = std::ranges::iterator_t<EnumerateView>;
+  using EnumerateConstIterator = std::ranges::iterator_t<const EnumerateView>;
+
+  auto make_enumerate_view = [](auto begin, auto end) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+
+    return EnumerateView(std::move(view));
+  };
+
+  static_assert(std::is_convertible_v<EnumerateIterator, EnumerateConstIterator>);
+
+  std::array array{0, 84, 2, 3, 4};
+  auto view = make_enumerate_view(array.begin(), array.end());
+  {
+    std::same_as<EnumerateIterator> decltype(auto) it     = view.begin();
+    std::same_as<const Iterator&> decltype(auto) itResult = it.base();
+    assert(base(base(itResult)) == array.begin());
+
+    auto [index, value] = *(++it);
+    assert(index == 1);
+    assert(value == 84);
+  }
+  {
+    std::same_as<EnumerateConstIterator> decltype(auto) it = view.begin();
+    std::same_as<const Iterator&> decltype(auto) itResult  = it.base();
+    assert(base(base(itResult)) == array.begin());
+
+    auto [index, value] = *(++it);
+    assert(index == 1);
+    assert(value == 84);
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// iterator() requires default_initializable<iterator_t<Base>>;
+
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, bool IsNoexcept = true>
+constexpr void test_default_constructible() {
+  using View              = MinimalView<Iterator, sentinel_wrapper<Iterator>>;
+  using EnumerateView     = std::ranges::enumerate_view<View>;
+  using EnumerateIterator = std::ranges::iterator_t<EnumerateView>;
+
+  EnumerateIterator it1;
+  EnumerateIterator it2{};
+
+  assert(it1 == it2);
+
+  static_assert(noexcept(EnumerateIterator()) == IsNoexcept);
+}
+
+template <class Iterator>
+constexpr void test_not_default_constructible() {
+  // Make sure the iterator is *not* default constructible when the underlying iterator isn't.
+  using Sentinel          = sentinel_wrapper<Iterator>;
+  using View              = MinimalView<Iterator, Sentinel>;
+  using EnumerateView     = std::ranges::enumerate_view<View>;
+  using EnumerateIterator = std::ranges::iterator_t<EnumerateView>;
+
+  static_assert(!std::is_default_constructible_v<EnumerateIterator>);
+}
+
+constexpr bool tests() {
+  // clang-format off
+  test_not_default_constructible<cpp17_input_iterator<int*>>();
+  test_not_default_constructible<cpp20_input_iterator<int*>>();
+  test_default_constructible<forward_iterator<int*>,       /* noexcept */ false>();
+  test_default_constructible<bidirectional_iterator<int*>, /* noexcept */ false>();
+  test_default_constructible<random_access_iterator<int*>, /* noexcept */ false>();
+  test_default_constructible<contiguous_iterator<int*>,    /* noexcept */ false>();
+  test_default_constructible<int*,                         /* noexcept */ true>();
+  // clang-format on
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// constexpr auto operator*() const;
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <cstddef>
+#include <utility>
+#include <tuple>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+template <class Iterator, class ValueType = int, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View              = MinimalView<Iterator, Sentinel>;
+  using EnumerateView     = std::ranges::enumerate_view<View>;
+  using EnumerateIterator = std::ranges::iterator_t<EnumerateView>;
+
+  using Result = std::tuple<typename EnumerateIterator::difference_type,
+                            std::ranges::range_reference_t<MinimalView<Iterator, Sentinel>>>;
+
+  std::array array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  View view{Iterator(array.begin()), Sentinel(Iterator(array.end()))};
+  EnumerateView ev{std::move(view)};
+
+  {
+    auto it = ev.begin();
+    for (std::size_t index = 0; index < array.size(); ++index) {
+      std::same_as<Result> decltype(auto) result = *it;
+
+      auto [resultIndex, resultValue] = result;
+      assert(std::cmp_equal(index, resultIndex));
+      assert(array[index] == resultValue);
+
+      ++it;
+    }
+
+    assert(it == ev.end());
+  }
+
+  // const
+  {
+    auto constIt = std::as_const(ev).begin();
+    for (std::size_t index = 0; index < array.size(); ++index) {
+      std::same_as<Result> decltype(auto) result = *constIt;
+
+      auto [resultIndex, resultValue] = result;
+      assert(std::cmp_equal(index, resultIndex));
+      assert(array[index] == resultValue);
+
+      ++constIt;
+    }
+
+    assert(constIt == ev.end());
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  test<cpp17_input_iterator<int const*>, int const>();
+  test<cpp20_input_iterator<int const*>, int const>();
+  test<forward_iterator<int const*>, int const>();
+  test<bidirectional_iterator<int const*>, int const>();
+  test<random_access_iterator<int const*>, int const>();
+  test<contiguous_iterator<int const*>, int const>();
+  test<int const*, int const>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/equal.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// friend constexpr bool operator==(const iterator& x, const iterator& y) noexcept;
+
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buff[] = {0, 1, 2, 3, 5};
+  {
+    using View = std::ranges::enumerate_view<RangeView>;
+    RangeView const range(buff, buff + 5);
+
+    std::same_as<View> decltype(auto) ev = std::views::enumerate(range);
+
+    auto it1 = ev.begin();
+    auto it2 = it1 + 5;
+
+    assert(it1 == it1);
+    ASSERT_NOEXCEPT(it1 == it1);
+    assert(it1 != it2);
+    ASSERT_NOEXCEPT(it1 != it2);
+    assert(it2 != it1);
+    ASSERT_NOEXCEPT(it2 != it1);
+    assert(it2 == ev.end());
+    assert(ev.end() == it2);
+
+    for (std::size_t index = 0; index != 5; ++index) {
+      ++it1;
+    }
+
+    assert(it1 == it2);
+    assert(it2 == it1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/index.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// constexpr difference_type index() const noexcept;
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <cstdint>
+#include <utility>
+#include <tuple>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+template <class Iterator, class ValueType = int, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View          = MinimalView<Iterator, Sentinel>;
+  using EnumerateView = std::ranges::enumerate_view<View>;
+
+  std::array array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  View view{Iterator(array.begin()), Sentinel(Iterator(array.end()))};
+  EnumerateView ev(std::move(view));
+
+  {
+    auto it = ev.begin();
+    ASSERT_NOEXCEPT(it.index());
+
+    static_assert(std::same_as<typename decltype(it)::difference_type, decltype(it.index())>);
+    for (std::size_t index = 0; index < array.size(); ++index) {
+      assert(std::cmp_equal(index, it.index()));
+
+      ++it;
+    }
+
+    assert(it == ev.end());
+  }
+
+  // const
+  {
+    auto constIt = std::as_const(ev).begin();
+    ASSERT_NOEXCEPT(constIt.index());
+
+    static_assert(std::same_as<typename decltype(constIt)::difference_type, decltype(constIt.index())>);
+    for (std::size_t index = 0; index < array.size(); ++index) {
+      assert(std::cmp_equal(index, constIt.index()));
+
+      ++constIt;
+    }
+
+    assert(constIt == ev.end());
+  }
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  test<cpp17_input_iterator<int const*>, int const>();
+  test<cpp20_input_iterator<int const*>, int const>();
+  test<forward_iterator<int const*>, int const>();
+  test<bidirectional_iterator<int const*>, int const>();
+  test<random_access_iterator<int const*>, int const>();
+  test<contiguous_iterator<int const*>, int const>();
+  test<int const*, int const>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// friend constexpr auto iter_move(const iterator& i)
+//   noexcept(noexcept(ranges::iter_move(i.current_)) &&
+//             is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>);
+
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "test_iterators.h"
+// #include "test_macros.h"
+#include "../types.h"
+
+template <class Iterator, bool HasNoexceptIterMove>
+constexpr void test() {
+  using Sentinel          = sentinel_wrapper<Iterator>;
+  using View              = MinimalView<Iterator, Sentinel>;
+  using EnumerateView     = std::ranges::enumerate_view<View>;
+  using EnumerateIterator = std::ranges::iterator_t<EnumerateView>;
+
+  std::array array{0, 1, 2, 3, 4};
+
+  View view{Iterator(array.begin()), Sentinel(Iterator(array.end()))};
+  EnumerateView ev{std::move(view)};
+  EnumerateIterator const it = ev.begin();
+
+  auto&& result = iter_move(it);
+
+  static_assert(std::is_same_v<decltype(result),
+                               std::tuple<typename std::ranges::iterator_t<EnumerateView>::difference_type, int&&>&&>);
+  static_assert(std::is_same_v<decltype(result), std::tuple<typename decltype(it)::difference_type, int&&>&&>);
+
+  assert(get<0>(result) == 0);
+  assert(&get<1>(result) == array.begin());
+
+  static_assert(noexcept(iter_move(it)) == HasNoexceptIterMove);
+  // static_assert(std::is_nothrow_move_constructible_v< std::ranges::range_rvalue_reference_t<decltype(base(it))>> == HasNoexceptIterMove);
+}
+
+constexpr bool tests() {
+  // clang-format off
+  test<cpp17_input_iterator<int*>,           /* noexcept */ false>();
+  test<cpp20_input_iterator<int*>,           /* noexcept */ false>();
+  test<forward_iterator<int*>,               /* noexcept */ false>();
+  test<bidirectional_iterator<int*>,         /* noexcept */ false>();
+  test<random_access_iterator<int*>,         /* noexcept */ false>();
+  test<contiguous_iterator<int*>,            /* noexcept */ false>();
+  test<int*,                                 /* noexcept */ true>();
+  test<MaybeNoexceptIterMoveInputIterator<true>,  /* noexcept */ true>();
+  test<MaybeNoexceptIterMoveInputIterator<false>, /* noexcept */ false>();
+  // clang-format on
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// constexpr auto operator[](difference_type n) const
+//   requires random_access_range<Base>;
+
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+#include "test_iterators.h"
+
+template <class T, class U>
+concept HasSubscriptOperator = requires(T t, U u) { t[u]; };
+
+template <class BaseRange>
+using EnumerateIterator = std::ranges::iterator_t<std::ranges::enumerate_view<BaseRange>>;
+
+using RandomAccessRange = std::ranges::subrange<int*>;
+static_assert(std::ranges::random_access_range<RandomAccessRange>);
+
+static_assert(HasSubscriptOperator<EnumerateIterator<RandomAccessRange>, int>);
+
+using BidirectionalRange = std::ranges::subrange<bidirectional_iterator<int*>>;
+static_assert(!std::ranges::random_access_range<BidirectionalRange>);
+
+static_assert(!HasSubscriptOperator<EnumerateIterator<BidirectionalRange>, int>);
+
+constexpr bool test() {
+  // Reference
+  {
+    std::array ts = {0, 1, 2, 3, 84};
+    auto view     = ts | std::views::enumerate;
+    auto it       = view.begin();
+
+    for (std::size_t index = 0; index != ts.size(); ++index) {
+      assert(it[index] == *(it + index));
+    }
+
+    static_assert(std::is_same_v<decltype(it[2]), std::tuple<decltype(it)::difference_type, int&>>);
+  }
+
+  // Value
+  {
+    auto view = std::views::iota(0, 5) | std::views::enumerate;
+    auto it   = view.begin();
+
+    for (std::size_t index = 0; index != 5; ++index) {
+      assert(it[index] == *(it + index));
+    }
+
+    static_assert(std::is_same_v<decltype(it[2]), std::tuple<decltype(it)::difference_type, int>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/iterator/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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::iterator
+
+// std::enumerate_view::<iterator>::difference_type;
+// std::enumerate_view::<iterator>::value_type;
+// std::enumerate_view::<iterator>::iterator_category;
+// std::enumerate_view::<iterator>::iterator_concept;
+
+#include <ranges>
+
+#include <type_traits>
+#include "test_iterators.h"
+#include "../types.h"
+
+template <typename T>
+concept HasIteratorCategory = requires { typename T::iterator_category; };
+
+template <class Iterator>
+using EnumerateViewFor = std::ranges::enumerate_view< MinimalView<Iterator, sentinel_wrapper<Iterator>>>;
+
+template <class Iterator>
+using EnumerateIteratorFor = std::ranges::iterator_t<EnumerateViewFor<Iterator>>;
+
+struct ForwardIteratorWithInputCategory {
+  using difference_type   = int;
+  using value_type        = int;
+  using iterator_category = std::input_iterator_tag;
+  using iterator_concept  = std::forward_iterator_tag;
+  ForwardIteratorWithInputCategory();
+  ForwardIteratorWithInputCategory& operator++();
+  ForwardIteratorWithInputCategory operator++(int);
+  int& operator*() const;
+  friend bool operator==(ForwardIteratorWithInputCategory, ForwardIteratorWithInputCategory);
+};
+static_assert(std::forward_iterator<ForwardIteratorWithInputCategory>);
+
+constexpr bool test() {
+  // Check that value_type is range_value_t and difference_type is range_difference_t
+  {
+    auto test = []<class Iterator> {
+      using EnumerateView     = EnumerateViewFor<Iterator>;
+      using EnumerateIterator = EnumerateIteratorFor<Iterator>;
+      static_assert(std::is_same_v<typename EnumerateIterator::value_type, std::ranges::range_value_t<EnumerateView>>);
+      static_assert(
+          std::is_same_v<typename EnumerateIterator::difference_type, std::ranges::range_difference_t<EnumerateView>>);
+    };
+    test.operator()<cpp17_input_iterator<int*>>();
+    test.operator()<cpp20_input_iterator<int*>>();
+    test.operator()<forward_iterator<int*>>();
+    test.operator()<bidirectional_iterator<int*>>();
+    test.operator()<random_access_iterator<int*>>();
+    test.operator()<contiguous_iterator<int*>>();
+    test.operator()<int*>();
+  }
+  // Check iterator_concept for various categories of ranges
+  {
+    static_assert(
+        std::is_same_v<EnumerateIteratorFor<cpp17_input_iterator<int*>>::iterator_concept, std::input_iterator_tag>);
+    static_assert(
+        std::is_same_v<EnumerateIteratorFor<cpp20_input_iterator<int*>>::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::is_same_v<EnumerateIteratorFor<ForwardIteratorWithInputCategory>::iterator_concept,
+                                 std::forward_iterator_tag>);
+    static_assert(
+        std::is_same_v<EnumerateIteratorFor<forward_iterator<int*>>::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::is_same_v<EnumerateIteratorFor<bidirectional_iterator<int*>>::iterator_concept,
+                                 std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<EnumerateIteratorFor<random_access_iterator<int*>>::iterator_concept,
+                                 std::random_access_iterator_tag>);
+    static_assert(std::is_same_v<EnumerateIteratorFor<contiguous_iterator<int*>>::iterator_concept,
+                                 std::random_access_iterator_tag>);
+    static_assert(std::is_same_v<EnumerateIteratorFor<int*>::iterator_concept, std::random_access_iterator_tag>);
+  }
+
+  // Check iterator_category for various categories of ranges
+  {
+    static_assert(HasIteratorCategory<EnumerateIteratorFor<cpp17_input_iterator<int*>>>);
+    static_assert(HasIteratorCategory<EnumerateIteratorFor<cpp20_input_iterator<int*>>>);
+    static_assert(std::is_same_v<EnumerateIteratorFor<ForwardIteratorWithInputCategory>::iterator_category,
+                                 std::input_iterator_tag>);
+    static_assert(
+        std::is_same_v<EnumerateIteratorFor<forward_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(
+        std::is_same_v<EnumerateIteratorFor<bidirectional_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(
+        std::is_same_v<EnumerateIteratorFor<random_access_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(
+        std::is_same_v<EnumerateIteratorFor<contiguous_iterator<int*>>::iterator_category, std::input_iterator_tag>);
+    static_assert(std::is_same_v<EnumerateIteratorFor<int*>::iterator_category, std::input_iterator_tag>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::sentinel
+
+// constexpr sentinel_t<Base> base() const;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View              = MinimalView<Iterator, Sentinel>;
+  using EnumerateView     = std::ranges::enumerate_view<View>;
+  using EnumerateSentinel = std::ranges::sentinel_t<EnumerateView>;
+
+  std::array<int, 5> array{0, 1, 2, 3, 84};
+
+  View mv{Iterator{array.begin()}, Sentinel{Iterator{array.end()}}};
+  EnumerateView ev{std::move(mv)};
+
+  EnumerateSentinel const s                    = ev.end();
+  std::same_as<Sentinel> decltype(auto) result = s.base();
+  assert(base(base(result)) == array.end());
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/sentinel/ctor.convert.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::sentinel
+
+//  constexpr sentinel(sentinel<!Const> other)
+//       requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View                   = MinimalView<Iterator, Sentinel>;
+  using EnumerateView          = std::ranges::enumerate_view<View>;
+  using EnumerateSentinel      = std::ranges::sentinel_t<EnumerateView>;
+  using EnumerateConstSentinel = std::ranges::sentinel_t<const EnumerateView>;
+
+  auto make_enumerate_view = [](auto begin, auto end) {
+    View view{Iterator(begin), Sentinel(Iterator(end))};
+
+    return EnumerateView(std::move(view));
+  };
+
+  static_assert(std::is_convertible_v<EnumerateSentinel, EnumerateConstSentinel>);
+
+  std::array array{0, 1, 2, 3, 84};
+  auto view = make_enumerate_view(array.begin(), array.end());
+
+  std::same_as<EnumerateSentinel> decltype(auto) s = view.end();
+  std::same_as<Sentinel> decltype(auto) sResult    = s.base();
+  assert(base(base(sResult)) == array.end());
+
+  // Test assignment
+  EnumerateConstSentinel cs                      = s;
+  std::same_as<Sentinel> decltype(auto) csResult = cs.base();
+  assert(base(base(csResult)) == array.end());
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::sentinel
+
+// sentinel() = default;
+
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+struct PODSentinel {
+  int i; // deliberately uninitialised
+
+  friend constexpr bool operator==(std::tuple<int>*, const PODSentinel&) { return true; }
+};
+
+template <typename Iterator, typename Sentinel>
+struct PODSentinelView : MinimalView<Iterator, Sentinel> {
+  std::tuple<int>* begin() const;
+  PODSentinel end();
+};
+
+template <class Iterator>
+constexpr void test() {
+  using Sentinel          = sentinel_wrapper<Iterator>;
+  using View              = PODSentinelView<Iterator, Sentinel>;
+  using EnumerateView     = std::ranges::enumerate_view<View>;
+  using EnumerateSentinel = std::ranges::sentinel_t<EnumerateView>;
+
+  {
+    EnumerateSentinel s;
+
+    assert(s.base().i == 0);
+  }
+
+  {
+    EnumerateSentinel s = {};
+
+    assert(s.base().i == 0);
+  }
+
+  static_assert(noexcept(EnumerateSentinel()));
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/sentinel/equal.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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::sentinel
+
+// template<bool OtherConst>
+//   requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
+constexpr void test() {
+  using View = MinimalView<Iterator, Sentinel>;
+
+  std::array array{0, 1, 2, 3, 84};
+
+  View v(Iterator(array.begin()), Sentinel(Iterator(array.end())));
+  std::ranges::enumerate_view view(std::move(v));
+
+  auto const it = view.begin();
+  auto const s  = view.end();
+
+  std::same_as<bool> decltype(auto) eqItSResult = (it == s);
+  assert(!eqItSResult);
+  std::same_as<bool> decltype(auto) eqSItResult = (s == it);
+  assert(!eqSItResult);
+
+  std::same_as<bool> decltype(auto) neqItSResult = (it != s);
+  assert(neqItSResult);
+  std::same_as<bool> decltype(auto) neqSItResult = (s != it);
+  assert(neqSItResult);
+}
+
+constexpr bool tests() {
+  test<cpp17_input_iterator<int*>>();
+  test<cpp20_input_iterator<int*>>();
+  test<forward_iterator<int*>>();
+  test<bidirectional_iterator<int*>>();
+  test<random_access_iterator<int*>>();
+  test<contiguous_iterator<int*>>();
+  test<int*>();
+
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+  static_assert(tests());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/sentinel/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, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// class enumerate_view::sentinel
+
+// template<bool OtherConst>
+//   requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+//   operator-(const iterator<OtherConst>& x, const sentinel& y);
+
+// template<bool OtherConst>
+//   requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+//   operator-(const sentinel& x, const iterator<OtherConst>& y);
+
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "../types.h"
+
+template <bool Const>
+struct Iter {
+  int* it_;
+
+  using value_type       = int;
+  using difference_type  = std::ptrdiff_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  constexpr decltype(auto) operator*() const { return *it_; }
+  constexpr Iter& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++it_; }
+};
+
+template <bool Const>
+struct Sent {
+  int* end_;
+
+  constexpr bool operator==(const Iter<Const>& i) const { return i.it_ == end_; }
+};
+
+template <bool Const>
+struct SizedSent {
+  int* end_;
+
+  constexpr bool operator==(const Iter<Const>& i) const { return i.it_ == end_; }
+
+  friend constexpr auto operator-(const SizedSent& st, const Iter<Const>& it) { return st.end_ - it.it_; }
+
+  friend constexpr auto operator-(const Iter<Const>& it, const SizedSent& st) { return it.it_ - st.end_; }
+};
+
+template <bool Const>
+struct CrossSizedSent {
+  int* end_;
+
+  template <bool C>
+  constexpr bool operator==(const Iter<C>& i) const {
+    return i.it_ == end_;
+  }
+
+  template <bool C>
+  friend constexpr auto operator-(const CrossSizedSent& st, const Iter<C>& it) {
+    return st.end_ - it.it_;
+  }
+
+  template <bool C>
+  friend constexpr auto operator-(const Iter<C>& it, const CrossSizedSent& st) {
+    return it.it_ - st.end_;
+  }
+};
+
+template <template <bool> class It, template <bool> class St>
+struct BufferView : std::ranges::view_base {
+  template <std::size_t N>
+  constexpr BufferView(int (&b)[N]) : buffer_(b), size_(N) {}
+
+  template <std::size_t N>
+  constexpr BufferView(std::array<int, N>& arr) : buffer_(arr.data()), size_(N) {}
+
+  using iterator       = It<false>;
+  using sentinel       = St<false>;
+  using const_iterator = It<true>;
+  using const_sentinel = St<true>;
+
+  constexpr iterator begin() { return {buffer_}; }
+  constexpr const_iterator begin() const { return {buffer_}; }
+  constexpr sentinel end() { return sentinel{buffer_ + size_}; }
+  constexpr const_sentinel end() const { return const_sentinel{buffer_ + size_}; }
+
+  int* buffer_;
+  std::size_t size_;
+};
+
+template <template <bool> class It, template <bool> class St>
+struct SizedBufferView : BufferView<It, St> {
+  constexpr std::size_t size() { return BufferView<It, St>::size_; }
+};
+
+template <class T, class U>
+concept HasMinus = requires(const T t, const U u) { t - u; };
+
+template <class BaseView>
+using EnumerateView = std::ranges::enumerate_view<BaseView>;
+
+template <class BaseView>
+using EnumerateIter = std::ranges::iterator_t<EnumerateView<BaseView>>;
+
+template <class BaseView>
+using EnumerateConstIter = std::ranges::iterator_t<const EnumerateView<BaseView>>;
+
+template <class BaseView>
+using EnumerateSentinel = std::ranges::sentinel_t<EnumerateView<BaseView>>;
+
+template <class BaseView>
+using EnumerateConstSentinel = std::ranges::sentinel_t<const EnumerateView<BaseView>>;
+
+constexpr void testConstraints() {
+  // Base is not sized
+  {
+    using Base = BufferView<Iter, Sent>;
+
+    static_assert(!HasSize<Base>);
+    static_assert(!std::ranges::sized_range<Base>);
+
+    static_assert(!HasMinus<EnumerateIter<Base>, EnumerateSentinel<Base>>);
+    static_assert(!HasMinus<EnumerateIter<Base>, EnumerateConstSentinel<Base>>);
+
+    static_assert(!HasMinus<EnumerateConstIter<Base>, EnumerateSentinel<Base>>);
+    static_assert(!HasMinus<EnumerateConstIter<Base>, EnumerateConstSentinel<Base>>);
+
+    static_assert(!HasMinus<EnumerateSentinel<Base>, EnumerateIter<Base>>);
+    static_assert(!HasMinus<EnumerateSentinel<Base>, EnumerateConstIter<Base>>);
+
+    static_assert(!HasMinus<EnumerateConstSentinel<Base>, EnumerateIter<Base>>);
+    static_assert(!HasMinus<EnumerateConstSentinel<Base>, EnumerateConstIter<Base>>);
+  }
+
+  // Base is sized but not cross const
+  {
+    using Base = SizedBufferView<Iter, SizedSent>;
+
+    static_assert(HasSize<Base>);
+    static_assert(std::ranges::sized_range<Base>);
+
+    static_assert(HasMinus<EnumerateIter<Base>, EnumerateSentinel<Base>>);
+    static_assert(!HasMinus<EnumerateIter<Base>, EnumerateConstSentinel<Base>>);
+
+    static_assert(!HasMinus<EnumerateConstIter<Base>, EnumerateSentinel<Base>>);
+    static_assert(HasMinus<EnumerateConstIter<Base>, EnumerateConstSentinel<Base>>);
+
+    static_assert(HasMinus<EnumerateSentinel<Base>, EnumerateIter<Base>>);
+    static_assert(!HasMinus<EnumerateSentinel<Base>, EnumerateConstIter<Base>>);
+
+    static_assert(!HasMinus<EnumerateConstSentinel<Base>, EnumerateIter<Base>>);
+    static_assert(HasMinus<EnumerateConstSentinel<Base>, EnumerateConstIter<Base>>);
+  }
+
+  // Base is cross const sized
+  {
+    using Base = BufferView<Iter, CrossSizedSent>;
+
+    static_assert(!HasSize<Base>);
+    static_assert(!std::ranges::sized_range<Base>);
+
+    static_assert(HasMinus<EnumerateIter<Base>, EnumerateSentinel<Base>>);
+    static_assert(HasMinus<EnumerateIter<Base>, EnumerateConstSentinel<Base>>);
+
+    static_assert(HasMinus<EnumerateConstIter<Base>, EnumerateSentinel<Base>>);
+    static_assert(HasMinus<EnumerateConstIter<Base>, EnumerateConstSentinel<Base>>);
+
+    static_assert(HasMinus<EnumerateSentinel<Base>, EnumerateIter<Base>>);
+    static_assert(HasMinus<EnumerateSentinel<Base>, EnumerateConstIter<Base>>);
+
+    static_assert(HasMinus<EnumerateConstSentinel<Base>, EnumerateIter<Base>>);
+    static_assert(HasMinus<EnumerateConstSentinel<Base>, EnumerateConstIter<Base>>);
+  }
+}
+
+constexpr bool test() {
+  int buffer[] = {1, 2, 3, 4, 5};
+
+  // Base is sized but not cross const
+  {
+    using Base = SizedBufferView<Iter, SizedSent>;
+
+    static_assert(HasSize<Base>);
+    static_assert(std::ranges::sized_range<Base>);
+
+    Base base{buffer};
+    auto ev         = base | std::views::enumerate;
+    auto iter       = ev.begin();
+    auto const_iter = std::as_const(ev).begin();
+    auto sent       = ev.end();
+    auto const_sent = std::as_const(ev).end();
+
+    assert(iter - sent == -5);
+    assert(sent - iter == 5);
+    assert(const_iter - const_sent == -5);
+    assert(const_sent - const_iter == 5);
+  }
+
+  // Base is cross const sized
+  {
+    using Base = BufferView<Iter, CrossSizedSent>;
+
+    static_assert(!HasSize<Base>);
+    static_assert(!std::ranges::sized_range<Base>);
+
+    Base base{buffer};
+    auto ev         = base | std::views::enumerate;
+    auto iter       = ev.begin();
+    auto const_iter = std::as_const(ev).begin();
+    auto sent       = ev.end();
+    auto const_sent = std::as_const(ev).end();
+
+    assert(iter - sent == -5);
+    assert(sent - iter == 5);
+    assert(iter - const_sent == -5);
+    assert(const_sent - iter == 5);
+    assert(const_iter - sent == -5);
+    assert(sent - const_iter == 5);
+    assert(const_iter - const_sent == -5);
+    assert(const_sent - const_iter == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <ranges>
+
+// class enumerate_view
+
+// constexpr auto size() requires sized_range<V>;
+// constexpr auto size() const requires sized_range<const V>;
+
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+#include "types.h"
+
+struct NonSizedRangeView : std::ranges::view_base {
+  using iterator = forward_iterator<int*>;
+  iterator begin() const;
+  iterator end() const;
+};
+
+static_assert(!std::ranges::sized_range<NonSizedRangeView>);
+static_assert(!std::ranges::sized_range<const NonSizedRangeView>);
+
+static_assert(!HasSize<std::ranges::enumerate_view<NonSizedRangeView>>);
+static_assert(!HasSize<const std::ranges::enumerate_view<NonSizedRangeView>>);
+
+constexpr bool test() {
+  int buffer[] = {1, 2, 3};
+
+  // Non-const and const are sized
+  {
+    auto view = std::views::enumerate(buffer);
+    assert(view.size() == 3);
+    assert(std::as_const(view).size() == 3);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.enumerate/types.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 TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ENUMERATE_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ENUMERATE_TYPES_H
+
+#include <ranges>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+// Types
+
+struct RangeView : std::ranges::view_base {
+  using Iterator = cpp20_input_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+
+  constexpr explicit RangeView(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr RangeView(RangeView const& other) : begin_(other.begin_), end_(other.end_), wasCopyInitialized(true) {}
+  constexpr RangeView(RangeView&& other) : begin_(other.begin_), end_(other.end_), wasMoveInitialized(true) {}
+  RangeView& operator=(RangeView const&) = default;
+  RangeView& operator=(RangeView&&)      = default;
+
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+  int* begin_;
+  int* end_;
+
+  bool wasCopyInitialized = false;
+  bool wasMoveInitialized = false;
+};
+
+LIBCPP_STATIC_ASSERT(std::ranges::__range_with_movable_references<RangeView>);
+static_assert(std::ranges::range<RangeView>);
+static_assert(std::ranges::view<RangeView>);
+
+struct SizedRangeView : public RangeView {
+  std::size_t size_;
+
+  constexpr std::size_t size() { return size_; }
+};
+
+static_assert(std::ranges::sized_range<SizedRangeView>);
+
+template <class T>
+concept HasSize = requires(T t) { t.size(); };
+
+static_assert(HasSize<std::ranges::enumerate_view<SizedRangeView>>);
+static_assert(HasSize<const std::ranges::enumerate_view<SizedRangeView>>);
+
+struct MinimalDefaultConstructedView : std::ranges::view_base {
+  MinimalDefaultConstructedView() = default;
+
+  forward_iterator<int*> begin() const;
+  sentinel_wrapper<forward_iterator<int*>> end() const;
+};
+
+static_assert(std::ranges::view<MinimalDefaultConstructedView>);
+
+template <class Iterator, class Sentinel>
+struct MinimalView : std::ranges::view_base {
+  constexpr explicit MinimalView(Iterator it, Sentinel sent) : it_(base(std::move(it))), sent_(base(std::move(sent))) {}
+
+  MinimalView(MinimalView&&)            = default;
+  MinimalView& operator=(MinimalView&&) = default;
+
+  constexpr Iterator begin() const { return Iterator(it_); }
+  constexpr Sentinel end() const { return Sentinel(sent_); }
+
+private:
+  decltype(base(std::declval<Iterator>())) it_;
+  decltype(base(std::declval<Sentinel>())) sent_;
+};
+
+static_assert(
+    std::ranges::view< MinimalView<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>>);
+
+struct NotInvocable {};
+
+static_assert(!std::invocable<NotInvocable>);
+
+struct NotAView {};
+
+static_assert(!std::ranges::view<NotAView>);
+
+struct NotAViewRange {
+  using Iterator = cpp20_input_iterator<int*>;
+  using Sentinel = sentinel_wrapper<Iterator>;
+
+  NotAViewRange() = default;
+  constexpr explicit NotAViewRange(int* b, int* e) : begin_(b), end_(e) {}
+  constexpr NotAViewRange(NotAViewRange const& other) = default;
+  constexpr NotAViewRange(NotAViewRange&& other)      = default;
+  NotAViewRange& operator=(NotAViewRange const&)      = default;
+  NotAViewRange& operator=(NotAViewRange&&)           = default;
+
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+  int* begin_;
+  int* end_;
+};
+
+static_assert(std::ranges::range<NotAViewRange>);
+static_assert(!std::ranges::view<NotAViewRange>);
+
+template <bool IsNoexcept>
+class MaybeNoexceptIterMoveInputIterator {
+  int* it_;
+
+public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type        = int;
+  using difference_type   = typename std::iterator_traits<int*>::difference_type;
+  using pointer           = int*;
+  using reference         = int&;
+
+  MaybeNoexceptIterMoveInputIterator() = default;
+  explicit constexpr MaybeNoexceptIterMoveInputIterator(int* it) : it_(it) {}
+
+  friend constexpr decltype(auto) iter_move(const MaybeNoexceptIterMoveInputIterator& it) noexcept(IsNoexcept) {
+    return std::ranges::iter_move(it.it_);
+  }
+
+  friend constexpr int* base(const MaybeNoexceptIterMoveInputIterator& i) { return i.it_; }
+
+  constexpr reference operator*() const { return *it_; }
+  constexpr MaybeNoexceptIterMoveInputIterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr MaybeNoexceptIterMoveInputIterator operator++(int) {
+    MaybeNoexceptIterMoveInputIterator tmp(*this);
+    ++(*this);
+    return tmp;
+  }
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ENUMERATE_TYPES_H

libcxx/utils/generate_feature_test_macro_components.py

for x in [
             "unimplemented": True,
         },
         {
             "name": "__cpp_lib_ranges_chunk_by",
             "values": {"c++23": 202202},
             "headers": ["ranges"],
         },
         {
+            "name": "__cpp_lib_ranges_enumerate",
+            "values": {"c++23": 202302},
+            "headers": ["ranges"],
+        },
+        {
             "name": "__cpp_lib_ranges_iota",
             "values": {"c++23": 202202},
             "headers": ["numeric"],
             "unimplemented": True,
         },
         {
             "name": "__cpp_lib_ranges_join_with",
             "values": {"c++23": 202202},