[libcxx][ranges] Add `ranges::iota_view`.

[zoecarver]

• Generate private header tests
• Add hide from ABI
• Remove log file

[cjdb]

Mostly LGTM, but a few blockers before I'm happy to give it a green light. A few more comments below.

• Can you please implement std::ranges::views::iota as well? That one doesn't need a closure, so we can* get away with adding it in this patch.
• Don't forget the range concept conformance test.
• You've got a 2.5K log file at the end of this; I don't think that's supposed to be there.

libcxx/include/__ranges/iota_view.h

65

Not that I super care, but why is this is_integral_v and not integral?

99

I really find it cluttering that the iterator is defined inside the range. Took me a whole two minutes to realise I was no longer reviewing iota_view, but rather iota_view::__iterator. (Two mins is probably a slight exaggeration, but it took me longer than I'd have liked.)

Can we please move the definition out-of-line to improve readability?

106–118

123

Since this type is exposition-only, I think we can make this constructor private. That'll lead to fewer users attempting to declare an iterator outright.

132–134

187–191

I'm surprised this can't be just = default;

245–248

I'd also like to see conditional operator use, but the salient feature of the suggested edit is the added else-clause.

250

262

Suggest making this private to limit user-touchability.

285

I know the standard has this, but I don't think it's strictly necessary?

290

I'd really like to see the precondition partially applied, particularly for integers, which are a very common use-case for iota_view. Same with the above constructor.

318–319

It took me editing this to realise that sized_sentinel_for doesn't have parens at all.

321–328

I'd honestly prefer a conditional expression here.

330

Please put this in an else-clause to account for constexpr instantiation..

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

2

Please add commented-out tests for <=>, or a FIXME, or both. We also still need to test != is not (x == y).

[zoecarver]

libcxx/include/__ranges/iota_view.h

123

It also means it's impossible to test.

But more importantly: the standard explicitly stated that this type must be default constructible. If users shouldn't care about it being default constructible, why do that? Why not leave it as an implementation detail? There's nothing about iota_view that requires this iterator to be default constructible.

245–248

We can discuss further about the conditional operator.

290

Just to make sure we're on the same page: you want if constexpr (in-debug-mode and is-valid-operation) _LIBCPP_ASSERT(ranges::less_equal(__value, __bound));? Done.

330

It seems like all compilers that we support, at least, are OK with this.

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

2

This is not testing == or !=. That's in eq.pass.cpp.

[zoecarver]

Apply Chris' comments.

[zoecarver]

Make ranges::iota_view<bool> invalid everywhere.

[zoecarver]

Make start private to fix friends in gcc.

[zoecarver]

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/minus.pass.cpp

49

@tcanens thoughts?

[ldionne]

libcxx/include/__ranges/iota_view.h

2

Can you also add views::iota in this patch? It's just a CPO, so it doesn't require the range adaptor stuff (which is close to being done BTW).

28

Not necessary.

44–61

64

Can you please add tests that checks the member typedefs of iota_view::iterator itself? In particular, I'd like to confirm that iterator_difference_t is deduced correctly when W::difference_type has sizes less than short, int, long, etc.

Note per our discussion: If it's not possible to have W::difference_type both be an integral type and be smaller than short, we should perhaps add a static_assert to keep us honest about it. But as we discussed, I think it is possible by having W::difference_type be char.

67

This _If is too eager. It will fail if you pass a non-integer-like-type to it that is larger than sizeof(long long), because you will eagerly instantiate __get_wider_signed_integer here and fail in the static_assert. This can be fixed by changing to this (not super pretty because we lack iter_difference, but oh-well):

template<class _Start>
using _IotaDiffT = typename _If<
  (!integral<_Start> || sizeof(iter_difference_t<_Start>) > sizeof(_Start)),
  type_identity<iter_difference_t<_Start>>,
  __get_wider_signed<_Start>
>::type;

Can you add a test with a non-integer type with a size that's larger than long long and confirm that it fails? If it does not fail, we'll learn something interesting. If it does, we can fix it.

99

I think the correct location to fix this issue is in whatever concept currently accepts bool when it shouldn't, which is weakly_incrementable IIUC. So I would suggest fixing that in weakly_incrementable with a && !same_as<bool, T>, along with a test that bool doesn't model weakly_incrementable (which we must be lacking right now), and also a TODO comment to remove the special case for bool once Clang has been fixed.

313

Do you test the explicitness by checking !std::is_convertible? If not, please do.

376–379

Possible spec issue:

I'm kind of wondering why we don't define the constructor like this instead, and avoid defining a deduction guide altogether:

constexpr iota_view(W value, Bound bound) 
    requires (!is-integer-like<W> || !is-integer-like<Bound> ||
             (is-signed-integer-like<W> == is-signed-integer-like<Bound>));

As specified in the Standard, we have the following situation, which seems to be weird and inconsistent:

iota_view<signed, unsigned> view(x, y); // works
iota_view view((signed)x, (unsigned)y); // doesn't work

I think both of them should not work.

@tcanens is that intentional?

libcxx/test/std/ranges/range.factories/range.iota.view/begin.pass.cpp

12

Not necessary anymore, we don't support GCC 10.

I have a patch to remove them everywhere, but it would be nice if we stopped introducing those in new patches from now on.

[ldionne]

libcxx/include/__ranges/iota_view.h

283

Nit: make sure you test explicitness.

319–321

That would match the spec better.

332

This is very nitpicky, but I would rather define this as iota_view(__iterator __first, _Bound __last) even though those are the same, simply because it matches the spec more closely and IMO it is easier to read that way (see http://eel.is/c++draft/range.iota#view-11.2).

363

Can you please add tests at boundary conditions like numeric_limits<T>::max() & friends?

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/minus.pass.cpp

49

Instead, can we add tests to confirm that this *doesn't* work? Can we file a LWG issue to relax this requirement? If this is indeed issue-worthy, our test is going to fail when we fix it, as it should.

libcxx/test/std/ranges/range.factories/range.iota.view/types.h

2

Missing license.

[• Quuxplusone]

Minor nits.

libcxx/include/__ranges/iota_view.h

99

+1 what Louis said; and anyway, since iota_view is supposed to be constrained, the mechanism needs to be SFINAE-friendly (as Louis's suggestion is). E.g. we expect https://godbolt.org/z/fcx3r61PT

template<class T> iota_view<T> f(int);
template<class T> void f(...);
int main() { f<bool>(42); }

to be unambiguous because SFINAE.

231–232

Nit: You might as well provide the commented-out definition of this function's body. Also, bool should be auto.

238

This matches the Standard reference implementation, but it might be worth noting that return a += b; does a copy-construct of parameter a, whereas a += b; return a; would do only a move-construct.

370

Style nit: Even though the arguments are going to be integral, I'd like to see the usual ADL-proofing on this function call: _VSTD::__to_unsigned_like(...) throughout.

libcxx/test/std/ranges/range.factories/range.iota.view/begin.pass.cpp

46–47

I notice a conspicuous lack of long long and unsigned long long here.
Notice that iota_view<long long>::difference_type needs to be __int128_t or some other integer-like class type suitable for holding the signed difference between LLONG_MIN and LLONG_MAX.

libcxx/test/std/ranges/range.factories/range.iota.view/types.h

148

I bet you could use forward_iterator<int*> out of test_iterators.h here, instead of having to invent your own type. You can make an iota_view<forward_iterator<int*>>, right?

[zoecarver]

libcxx/include/__ranges/iota_view.h

2

I will do this later tonight or tomorrow morning.

67

error: static_assert failed due to requirement 'sizeof(BigType) <= sizeof(long long)' "Found integer-like type that is bigger than largest integer like type."

libcxx/test/std/ranges/range.factories/range.iota.view/begin.pass.cpp

46–47

Notice that iota_view<long long>::difference_type needs to be __int128_t or some other integer-like class type suitable for holding the signed difference between LLONG_MIN and LLONG_MAX.

Is that standard? Are we supposed to support types larger than long? That is why I dropped it from this test. (I should have made a comment, though).

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/minus.pass.cpp

49

Test added. I'll file the LWG issue tomorrow.

libcxx/test/std/ranges/range.factories/range.iota.view/types.h

148

While I suppose we could, the problem is we need to somehow get a buffer to forward_iterator and then we can't use it to test a default constructible iterator. I think this is a bit simpler.

[zoecarver]

Apply review comments

[cjdb]

libcxx/include/__ranges/iota_view.h

258–261

319–321

This suggestion is too general: we're deliberately restricting this to integers and pointers because general reachability is not detectable.

356–362

Yes, I inverted the first condition and moved it to the top.

libcxx/test/std/ranges/range.factories/range.iota.view/begin.pass.cpp

46–47

Are we supposed to support types larger than long?

Yes, this is a reason why integer-like exists.

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

2

I count four assertions for an ==?

[tcanens]

libcxx/include/__ranges/iota_view.h

376–379

This seems to me to be a "we'll protect you from accidentally shooting yourself in your foot, but not from intentionally pointing your gun at your foot and pulling the trigger" case. Mixing signs isn't inherently incorrect, so if people want to do it explicitly they can, but the deduction guide forces the type to be spelled out so that the mixedness is obvious.

It's more of an Eric/Casey question though.

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/minus.pass.cpp

49

sized_sentinel_for has an opt-out, and any relaxation would need to both respect that and perhaps supply its own opt-out mechanism. That gets hairy pretty quickly and doesn't seem to be worth the extra complexity.

[zoecarver]

libcxx/include/__ranges/iota_view.h

258–261

The conditional expression here does not seem easier to read. I could see an argument for it to be the same difficulty, but to me it is harder to read than the if statement. I don't see a reason to change this.

319–321

What does "general reachability is not detectable" mean?

I think this is fine because the standard says:

Preconditions: Bound denotes unreachable_­sentinel_­t or bound is reachable from value. When W and Bound model totally_­ordered_­with, then bool(value <= bound) is true.

356–362

Same as above, but this is even harder to read. I really think nested ternaries are an anti pattern, especially when there is a lot going on in each condition. If it was just a variable, that would be one thing, but there are operators inside operators inside operators here, and that makes this very hard to parse. What are we gaining by using the conditional operator here?

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

2

It's just a sanity check to show that we're starting from the same place. If you feel strongly I can remove them.

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/minus.pass.cpp

49

I will never understand the decision matrix that leads to the Committee thinking some things are worth the complexity and others aren't :P

Anyway, thanks for the info about this, Tim. I guess I won't file an LWG issue, then.

[zoecarver]

libcxx/include/__ranges/iota_view.h

376–379

This seems to me to be a "we'll protect you from accidentally shooting yourself in your foot, but not from intentionally pointing your gun at your foot and pulling the trigger" case. Mixing signs isn't inherently incorrect, so if people want to do it explicitly they can, but the deduction guide forces the type to be spelled out so that the mixedness is obvious.

This logic makes sense. I suppose that also explains why the deduction guide is here in the first place (and we don't just remove the type_identity_ts from the _Start/_Bound ctor). As always, thanks for interpreting the Standard for us :)

[zoecarver]

• Add views::iota.
• Fix all the bots except for UBSan.

[ldionne]

libcxx/include/__ranges/iota_view.h

31–38

This can go away now too.

41

This can go away.

376–379

Ping @CaseyCarter, is that really the intent here?

@zoecarver For the time being, can you please make sure those are tested? I'd like a test that fails if we add the constraints to the constructor, and one that fails if we remove them from the deduction guide.

380–390

Those are not expression-equivalent as they are required to by http://eel.is/c++draft/range.iota#overview-2. Please also add tests that we're SFINAE friendly (which would fail right now).

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/member_typedefs.compile.pass.cpp

93

109

As you said live, I think this is valid per https://eel.is/c++draft/range.iota.view#1.3. I would suggest this:

// comment with link to spec
static_assert(sizeof(Iter::difference_type) >= sizeof(long long));
static_assert(std::is_signed_v<Iter::difference_type>);
LIBCPP_STATIC_ASSERT(std::same_as<Iter::difference_type, long long>);

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/minus.pass.cpp

24–28

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/minus.pass.cpp

57

This should go away now. And the comment above with !MinusInvocable<int> should be fixed.

[zoecarver]

Rebase and apply review comments.

[ldionne]

LGTM assuming you fix my comments and CI passes! Thanks!

libcxx/test/std/ranges/range.factories/range.iota.view/begin.pass.cpp

2

Throughout: please make sure you test mixing signed and unsigned bounds (and unsigned/signed too).

libcxx/test/std/ranges/range.factories/range.iota.view/size.pass.cpp

40

This is currently UB until we fix the spec IIUC. Please comment it out and add a comment explaining this is pending on LWG issue resolution.

91

Uncomment this.

[zoecarver]

Apply comments.

[zoecarver]

Fix modules build and windows build.

[cjdb]

Please add range concept conformance tests.

libcxx/include/__ranges/iota_view.h

45

Since Clang supports __int128 and acknowledges that as an integral type (as does libc++), we should fix this to account for that too.

95

Keep the conditions and the results in distinct columns please.

238

Since it's an effects-equivalent-to, I'm not sure if we're allowed to change this at all without first filing an LWG issue (which I'd be okay with). @tcanens any input?

241

This should match operator+= or vice versa.

258–261

We're at a bit of an impasse then, because I find the if-statement approach to be the less-readable one.

319–321

Being able to detect whether an iterator can reach a sentinel is not something that we can always check. However, given that precondition, I think it's okay in this case.

356–362

especially when there is a lot going on in each condition

The conditions are very simple.

I really think nested ternaries are an anti pattern

The reason I inverted the expression and moved it to the top was to flatten the expression. In its current state, there the expressions aren't nested (but the standard wording is nested).

What are we gaining by using the conditional operator here?

It's flat and it's a single expression that can be reasoned about. The way the proposes conditional expression is structured is the same as my rewrite of iterator_concept and similar to Louis' rewrite of __get_wideer_signed.
By collecting these if-statements into a single expression, we transform imperative code into declarative code, which reduces complexity, and we get to rely on pattern matching:

case 1    -> result 1
case 2    -> result 2
otherwise -> default result

370–371

Please move this into namespace ranges.

378

What's wrong with having an auto return type?

387

Ditto.

393–396

Up to you as to whether or not you wanna do it in this patch or separately, but please add the following to <ranges>:

_LIBCPP_BEGIN_NAMESPACE_STD

namespace views = namespace ranges::views;

_LIBCPP_END_NAMESPACE_STD

Now that we've got something in ranges::views, this is worth adding ASAP.

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

2

Oh, in that case please rename it to inequality.pass.cpp, since I thought this was checking all the comparison operations, not just inequalities.

libcxx/test/std/ranges/range.factories/range.iota.view/views_iota.pass.cpp

2

You'll also need to add tests for std::ranges::views::iota.

[zoecarver]

libcxx/include/__ranges/iota_view.h

45

As we discussed offline, I have concerns about portability here.

I'd be open to it, but let's do it in it's own patch so we can discuss more thoroughly.

238

I'll send something to the lwg chair.

241

done.

258–261

See discord discussion.

370–371

Done in a separate patch.

378

(As discussed offline) We want this for SFINAE.

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

2

I just deleted eq.pass.cpp and test not-equals here.

[• Quuxplusone]

libcxx/include/__ranges/iota_view.h

258–261

IIUC, you're discussing the cascade that currently looks like this:

if constexpr (__integer_like<_Start>) {
  if constexpr (__signed_integer_like<_Start>) {
    return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
  }
  if (__y.__value_ > __x.__value_) {
    return difference_type(-difference_type(__y.__value_ - __x.__value_));
  }
  return difference_type(__x.__value_ - __y.__value_);
}
return __x.__value_ - __y.__value_;

for which the Standard reference implementation is

if constexpr (is-integer-like<W>) {
  if constexpr (is-signed-integer-like<W>)
    return D(D(x.value_) - D(y.value_));
  else
    return (y.value_ > x.value_)
      ? D(-D(y.value_ - x.value_))
      : D(x.value_ - y.value_);
} else {
  return x.value_ - y.value_;
}

Personally I'd recommend sticking to the reference implementation (including the ?:), to make it easy to verify that libc++ matches the Standard-mandated behavior (even though it is not obvious what that behavior actually is!). Alternatively, if we wanted to make it easy to read the code, one way to do that is to disentangle the nested ifs and turn it into a plain if-else-if ladder:

if constexpr (!__integer_like<_Start>) {
  return __x.__value_ - __y.__value_;
} else if constexpr (__signed_integer_like<_Start>) {
  return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
} else if (__y.__value_ > __x.__value_) {
  return difference_type(-difference_type(__y.__value_ - __x.__value_));
} else {
  return difference_type(__x.__value_ - __y.__value_);
}

Writing it out longhand this way really illustrates the insanity of the reference implementation: each branch puts its explicit casts to difference_type in different places! Particularly the first and fourth branches (in the if-else-if ladder version above) are gratuitously different: the first uses an implicit conversion, the last an explicit conversion. If these conversions can have observably different behavior, something is seriously broken.

libcxx/docs/Status/RangesPaper.csv

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

libcxx/include/CMakeLists.txt

set(files
   __ranges/copyable_box.h
   __ranges/dangling.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
+  __ranges/iota_view.h
   __ranges/non_propagating_cache.h
   __ranges/ref_view.h
   __ranges/reverse_view.h
   __ranges/take_view.h
   __ranges/single_view.h
   __ranges/size.h
   __ranges/subrange.h
   __ranges/take_view.h

libcxx/include/__iterator/concepts.h

 template<class _Tp>
 concept __integer_like = integral<_Tp> && !same_as<_Tp, bool>;
 
 template<class _Tp>
 concept __signed_integer_like = signed_integral<_Tp>;
 
 template<class _Ip>
 concept weakly_incrementable =
+  // TODO: remove this once the clang bug is fixed (bugs.llvm.org/PR48173).
+  !same_as<_Ip, bool> && // Currently, clang does not handle bool correctly.
   movable<_Ip> &&
   requires(_Ip __i) {
     typename iter_difference_t<_Ip>;
     requires __signed_integer_like<iter_difference_t<_Ip>>;
     { ++__i } -> same_as<_Ip&>;   // not required to be equality-preserving
     __i++;                        // not required to be equality-preserving
   };
 

libcxx/include/__ranges/iota_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_IOTA_VIEW_H
+#define _LIBCPP___RANGES_IOTA_VIEW_H
+
+#include <__config>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/copyable_box.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/view_interface.h>
+#include <concepts>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// REVIEW-NOTE: Will be its own patch. Not up for review.
+struct unreachable_sentinel_t {
+  template<weakly_incrementable _Iter>
+  friend constexpr bool operator==(unreachable_sentinel_t, const _Iter&) noexcept { return false; }
+};
+
+inline constexpr unreachable_sentinel_t unreachable_sentinel{};
+// END-REVIEW-NOTE
+
+namespace ranges {
+  // TODO: Add a test where diff type size is smaller than short (both int and not) and larger.
+
+  template<class _Int>
+  struct __get_wider_signed {
+    static auto __call() {
+           if constexpr (sizeof(_Int) < sizeof(short)) return type_identity<short>{};
+      else if constexpr (sizeof(_Int) < sizeof(int))   return type_identity<int>{};
+      else if constexpr (sizeof(_Int) < sizeof(long))  return type_identity<long>{};
+      else                                             return type_identity<long long>{};
+
+      static_assert(sizeof(_Int) <= sizeof(long long),
+        "Found integer-like type that is bigger than largest integer like type.");
+    }
+
+    using type = typename decltype(__call())::type;
+  };
+
+  template<class _Start>
+  using _IotaDiffT = typename _If<
+      (!integral<_Start> || sizeof(iter_difference_t<_Start>) > sizeof(_Start)),
+      type_identity<iter_difference_t<_Start>>,
+      __get_wider_signed<_Start>
+    >::type;
+
+  template<class _Iter>
+  concept __decrementable = incrementable<_Iter> && requires(_Iter __i) {
+    { --__i } -> same_as<_Iter&>;
+    { __i-- } -> same_as<_Iter>;
+  };
+
+  template<class _Iter>
+  concept __advanceable =
+    __decrementable<_Iter> && totally_ordered<_Iter> &&
+    requires(_Iter __i, const _Iter __j, const _IotaDiffT<_Iter> __n) {
+      { __i += __n } -> same_as<_Iter&>;
+      { __i -= __n } -> same_as<_Iter&>;
+      _Iter(__j + __n);
+      _Iter(__n + __j);
+      _Iter(__j - __n);
+      { __j - __j } -> convertible_to<_IotaDiffT<_Iter>>;
+    };
+
+  template<class>
+  struct __iota_iterator_category {};
+
+  template<incrementable _Tp>
+  struct __iota_iterator_category<_Tp> {
+    using iterator_category = input_iterator_tag;
+  };
+
+  template<weakly_incrementable _Start, semiregular _Bound = unreachable_sentinel_t>
+    requires __weakly_equality_comparable_with<_Start, _Bound> && copyable<_Start>
+  class iota_view : public view_interface<iota_view<_Start, _Bound>> {
+    struct __iterator : public __iota_iterator_category<_Start> {
+      friend class iota_view;
+
+      using iterator_concept =
+        _If<__advanceable<_Start>, random_access_iterator_tag,
+        _If<__decrementable<_Start>, bidirectional_iterator_tag,
+        _If<incrementable<_Start>, forward_iterator_tag,
+    /*Else*/input_iterator_tag>>>;
+
+      using value_type = _Start;
+      using difference_type = _IotaDiffT<_Start>;
+
+      _Start __value_ = _Start();
+
+      _LIBCPP_HIDE_FROM_ABI
+      __iterator() requires default_initializable<_Start> = default;
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr explicit __iterator(_Start __value) : __value_(_VSTD::move(__value)) {}
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {
+        return __value_;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr __iterator& operator++() {
+        ++__value_;
+        return *this;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr void operator++(int) { ++*this; }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr __iterator operator++(int) requires incrementable<_Start> {
+        auto __tmp = *this;
+        ++*this;
+        return __tmp;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr __iterator& operator--() requires __decrementable<_Start> {
+        --__value_;
+        return *this;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr __iterator  operator--(int) requires __decrementable<_Start> {
+        auto __tmp = *this;
+        --*this;
+        return __tmp;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr __iterator& operator+=(difference_type __n)
+        requires __advanceable<_Start>
+      {
+        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
+          if (__n >= difference_type(0)) {
+            __value_ += static_cast<_Start>(__n);
+          } else {
+            __value_ -= static_cast<_Start>(-__n);
+          }
+        } else {
+          __value_ += __n;
+        }
+        return *this;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr __iterator& operator-=(difference_type __n)
+        requires __advanceable<_Start>
+      {
+        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
+          if (__n >= difference_type(0)) {
+            __value_ -= static_cast<_Start>(__n);
+          } else {
+            __value_ += static_cast<_Start>(-__n);
+          }
+        } else {
+          __value_ -= __n;
+        }
+        return *this;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr _Start operator[](difference_type __n) const
+        requires __advanceable<_Start>
+      {
+        return _Start(__value_ + __n);
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+        requires equality_comparable<_Start>
+      {
+        return __x.__value_ == __y.__value_;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+        requires totally_ordered<_Start>
+      {
+        return __x.__value_ < __y.__value_;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+        requires totally_ordered<_Start>
+      {
+        return __y < __x;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+        requires totally_ordered<_Start>
+      {
+        return !(__y < __x);
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+        requires totally_ordered<_Start>
+      {
+        return !(__x < __y);
+      }
+
+//       friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+//         requires totally_ordered<_Start> && three_way_comparable<_Start>
+//       {
+//         return __x.__value_ <=> __y.__value_;
+//       }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+        requires __advanceable<_Start>
+      {
+        __i += __n;
+        return __i;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+        requires __advanceable<_Start>
+      {
+        return __i + __n;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+        requires __advanceable<_Start>
+      {
+        return __i -= __n;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+        requires __advanceable<_Start>
+      {
+        if constexpr (__integer_like<_Start>) {
+          if constexpr (__signed_integer_like<_Start>) {
+            return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
+          }
+          if (__y.__value_ > __x.__value_) {
+            return difference_type(-difference_type(__y.__value_ - __x.__value_));
+          }
+          return difference_type(__x.__value_ - __y.__value_);
+        }
+        return __x.__value_ - __y.__value_;
+      }
+    };
+
+    struct __sentinel {
+      friend class iota_view;
+
+    private:
+      _Bound __bound_ = _Bound();
+
+    public:
+      _LIBCPP_HIDE_FROM_ABI
+      __sentinel() = default;
+      constexpr explicit __sentinel(_Bound __bound) : __bound_(_VSTD::move(__bound)) {}
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
+        return __x.__value_ == __y.__bound_;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr iter_difference_t<_Start> operator-(const __iterator& __x, const __sentinel& __y)
+        requires sized_sentinel_for<_Bound, _Start>
+      {
+        return __x.__value_ - __y.__bound_;
+      }
+
+      _LIBCPP_HIDE_FROM_ABI
+      friend constexpr iter_difference_t<_Start> operator-(const __sentinel& __x, const __iterator& __y)
+        requires sized_sentinel_for<_Bound, _Start>
+      {
+        return -(__y - __x);
+      }
+    };
+
+    _Start __value_ = _Start();
+    _Bound __bound_ = _Bound();
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    iota_view() requires default_initializable<_Start> = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit iota_view(_Start __value) : __value_(_VSTD::move(__value)) { }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(type_identity_t<_Start> __value, type_identity_t<_Bound> __bound)
+      : __value_(_VSTD::move(__value)), __bound_(_VSTD::move(__bound)) {
+      // Validate the precondition if possible.
+      if constexpr (totally_ordered_with<_Start, _Bound>) {
+        _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_),
+                       "Precondition violated: value is greater than bound.");
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(__iterator __first, __iterator __last)
+      requires same_as<_Start, _Bound>
+      : iota_view(_VSTD::move(__first.__value_), _VSTD::move(__last.__value_)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(__iterator __first, _Bound __last)
+      requires same_as<_Bound, unreachable_sentinel_t>
+      : iota_view(_VSTD::move(__first.__value_), _VSTD::move(__last)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iota_view(__iterator __first, __sentinel __last)
+      requires (!same_as<_Start, _Bound> && !same_as<_Start, unreachable_sentinel_t>)
+      : iota_view(_VSTD::move(__first.__value_), _VSTD::move(__last.__bound_)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator begin() const { return __iterator{__value_}; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto end() const {
+      if constexpr (same_as<_Bound, unreachable_sentinel_t>)
+        return unreachable_sentinel;
+      else
+        return __sentinel{__bound_};
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator end() const requires same_as<_Start, _Bound> {
+      return __iterator{__bound_};
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto size() const
+      requires (same_as<_Start, _Bound> && __advanceable<_Start>) ||
+               (integral<_Start> && integral<_Bound>) ||
+               sized_sentinel_for<_Bound, _Start>
+    {
+      if constexpr (__integer_like<_Start> && __integer_like<_Bound>) {
+        if (__value_ < 0) {
+          if (__bound_ < 0) {
+            return _VSTD::__to_unsigned_like(-__value_) - _VSTD::__to_unsigned_like(-__bound_);
+          }
+          return _VSTD::__to_unsigned_like(__bound_) + _VSTD::__to_unsigned_like(-__value_);
+        }
+        return _VSTD::__to_unsigned_like(__bound_) - _VSTD::__to_unsigned_like(__value_);
+      }
+      return _VSTD::__to_unsigned_like(__bound_ - __value_);
+    }
+  };
+
+  template<class _Start, class _Bound>
+    requires (!__integer_like<_Start> || !__integer_like<_Bound> ||
+              (__signed_integer_like<_Start> == __signed_integer_like<_Bound>))
+  iota_view(_Start, _Bound) -> iota_view<_Start, _Bound>;
+
+  template<class _Start, class _Bound>
+  inline constexpr bool enable_borrowed_range<iota_view<_Start, _Bound>> = true;
+} // namespace ranges
+
+namespace views {
+namespace __iota {
+  struct __fn {
+    template<class _Start>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Start&& __start) const {
+      return ranges::iota_view(_VSTD::forward<_Start>(__start));
+    }
+
+    template<class _Start, class _Bound>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Start&& __start, _Bound&& __bound) const {
+      return ranges::iota_view(_VSTD::forward<_Start>(__start), _VSTD::forward<_Bound>(__bound));
+    }
+  };
+} // namespace __iota
+
+inline namespace __cpo {
+  inline constexpr auto iota = __iota::__fn{};
+}
+} // namespace views
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_IOTA_VIEW_H

libcxx/include/module.modulemap

module __ranges {
       module copyable_box           { private header "__ranges/copyable_box.h"          }
       module dangling               { private header "__ranges/dangling.h"              }
       module data                   { private header "__ranges/data.h"                  }
       module drop_view              { private header "__ranges/drop_view.h"             }
       module empty                  { private header "__ranges/empty.h"                 }
       module empty_view             { private header "__ranges/empty_view.h"            }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h"           }
+      module iota_view              { private header "__ranges/iota_view.h"             }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module ref_view               { private header "__ranges/ref_view.h"              }
       module reverse_view           { private header "__ranges/reverse_view.h"          }
       module size                   { private header "__ranges/size.h"                  }
       module single_view            { private header "__ranges/single_view.h"           }
       module subrange               { private header "__ranges/subrange.h"              }
       module take_view              { private header "__ranges/take_view.h"             }
       module transform_view         { private header "__ranges/transform_view.h"        }

libcxx/include/ranges

// [range.reverse], reverse view
   template<view> class take_view;
 
   template<class T>
   inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
 
   template<copy_constructible T>
     requires is_object_v<T>
   class single_view;
+
+  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
+    requires weakly-equality-comparable-with<W, Bound> && copyable<W>
+  class iota_view;
+
+  template<class W, class Bound>
+    inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
 }
 
 */
 
 // Make sure all feature tests macros are always available.
 #include <version>
 // Only enable the contents of the header when libc++ was build with LIBCXX_ENABLE_INCOMPLETE_FEATURES enabled
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
+#include <__ranges/iota_view.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/take_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/transform_view.h>

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

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/iota_view.h'}}
+#include <__ranges/iota_view.h>

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp

 static_assert(std::weakly_incrementable<int**>);
 static_assert(!std::weakly_incrementable<int[]>);
 static_assert(!std::weakly_incrementable<int[10]>);
 static_assert(!std::weakly_incrementable<double>);
 static_assert(!std::weakly_incrementable<int&>);
 static_assert(!std::weakly_incrementable<int()>);
 static_assert(!std::weakly_incrementable<int (*)()>);
 static_assert(!std::weakly_incrementable<int (&)()>);
+static_assert(!std::weakly_incrementable<bool>);
 
 struct S {};
 static_assert(!std::weakly_incrementable<int S::*>);
 
 #define CHECK_POINTER_TO_MEMBER_FUNCTIONS(qualifier)                                                                   \
   static_assert(!std::weakly_incrementable<int (S::*)() qualifier>);                                                   \
   static_assert(!std::weakly_incrementable<int (S::*)() qualifier noexcept>);                                          \
   static_assert(!std::weakly_incrementable<int (S::*)() qualifier&>);                                                  \

libcxx/test/std/ranges/range.factories/range.iota.view/begin.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator begin() const;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+constexpr void testType() {
+  {
+    std::ranges::iota_view<T> io(T(0));
+    assert(*io.begin() == T(0));
+  }
+  {
+    std::ranges::iota_view<T> io(T(10));
+    assert(*io.begin() == T(10));
+    assert(*std::move(io).begin() == T(10));
+  }
+  {
+    const std::ranges::iota_view<T> io(T(0));
+    assert(*io.begin() == T(0));
+  }
+  {
+    const std::ranges::iota_view<T> io(T(10));
+    assert(*io.begin() == T(10));
+  }
+}
+
+constexpr bool test() {
+  testType<SomeInt>();
+  testType<long long>();
+  testType<unsigned long long>();
+  testType<signed long>();
+  testType<unsigned long>();
+  testType<int>();
+  testType<unsigned>();
+  testType<short>();
+  testType<unsigned short>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/borrowing.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class W, class Bound>
+//   inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+#include "test_macros.h"
+#include "types.h"
+
+static_assert(std::ranges::enable_borrowed_range<std::ranges::iota_view<int, int>>);
+static_assert(std::ranges::enable_borrowed_range<std::ranges::iota_view<int, std::unreachable_sentinel_t>>);
+static_assert(std::ranges::enable_borrowed_range<std::ranges::iota_view<int, IntComparableWith<int>>>);

libcxx/test/std/ranges/range.factories/range.iota.view/ctad.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class W, class Bound>
+//     requires (!is-integer-like<W> || !is-integer-like<Bound> ||
+//               (is-signed-integer-like<W> == is-signed-integer-like<Bound>))
+//     iota_view(W, Bound) -> iota_view<W, Bound>;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+#include "test_macros.h"
+#include "types.h"
+
+void test() {
+  static_assert(std::same_as<
+    decltype(std::ranges::iota_view(0, 0)),
+    std::ranges::iota_view<int, int>
+  >);
+
+  static_assert(std::same_as<
+    decltype(std::ranges::iota_view(0)),
+    std::ranges::iota_view<int, std::unreachable_sentinel_t>
+  >);
+
+  static_assert(std::same_as<
+    decltype(std::ranges::iota_view(0, std::unreachable_sentinel)),
+    std::ranges::iota_view<int, std::unreachable_sentinel_t>
+  >);
+
+  static_assert(std::same_as<
+    decltype(std::ranges::iota_view(0, IntComparableWith(0))),
+    std::ranges::iota_view<int, IntComparableWith<int>>
+  >);
+}

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// iota_view() requires default_­initializable<W> = default;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  {
+    std::ranges::iota_view<Int42<DefaultTo42>> io;
+    assert((*io.begin()).value_ == 42);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  static_assert(!std::default_initializable<Int42<ValueCtor>>);
+  static_assert( std::default_initializable<Int42<DefaultTo42>>);
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.first.last.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iota_view(iterator first, see below last);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  {
+    std::ranges::iota_view commonView(SomeInt(0), SomeInt(10));
+    std::ranges::iota_view<SomeInt, SomeInt> io(commonView.begin(), commonView.end());
+    assert(std::ranges::next(io.begin(), 10) == io.end());
+  }
+
+  {
+    std::ranges::iota_view unreachableSent(SomeInt(0));
+    std::ranges::iota_view<SomeInt> io(unreachableSent.begin(), std::unreachable_sentinel);
+    assert(std::ranges::next(io.begin(), 10) != io.end());
+  }
+
+  {
+    std::ranges::iota_view differentTypes(SomeInt(0), IntComparableWith(SomeInt(10)));
+    std::ranges::iota_view<SomeInt, IntComparableWith<SomeInt>> io(differentTypes.begin(), differentTypes.end());
+    assert(std::ranges::next(io.begin(), 10) == io.end());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
+

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.value.bound.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  {
+    std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(0), SomeInt(10));
+    assert(std::ranges::next(io.begin(), 10) == io.end());
+  }
+
+  {
+    std::ranges::iota_view<SomeInt> io(SomeInt(0), std::unreachable_sentinel);
+    assert(std::ranges::next(io.begin(), 10) != io.end());
+  }
+
+  {
+    std::ranges::iota_view<SomeInt, IntComparableWith<SomeInt>> io(SomeInt(0), IntComparableWith(SomeInt(10)));
+    assert(std::ranges::next(io.begin(), 10) == io.end());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
+

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.value.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit iota_view(W value);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "types.h"
+
+struct SomeIntComparable {
+  using difference_type = int;
+
+  SomeInt value_;
+  constexpr SomeIntComparable() : value_(SomeInt(10)) {}
+
+  friend constexpr bool operator==(SomeIntComparable lhs, SomeIntComparable rhs) {
+    return lhs.value_ == rhs.value_;
+  }
+  friend constexpr bool operator==(SomeIntComparable lhs, SomeInt rhs) {
+    return lhs.value_ == rhs;
+  }
+  friend constexpr bool operator==(SomeInt lhs, SomeIntComparable rhs) {
+    return lhs == rhs.value_;
+  }
+
+  friend constexpr difference_type operator-(SomeIntComparable lhs, SomeIntComparable rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+
+  constexpr SomeIntComparable& operator++() { ++value_; return *this; }
+  constexpr SomeIntComparable  operator++(int) { auto tmp = *this; ++value_; return tmp; }
+  constexpr SomeIntComparable  operator--() { --value_; return *this; }
+};
+
+constexpr bool test() {
+  {
+    std::ranges::iota_view<SomeInt> io(SomeInt(42));
+    assert((*io.begin()).value_ == 42);
+    // Check that end returns std::unreachable_sentinel.
+    assert(io.end() != io.begin());
+    static_assert(std::same_as<decltype(io.end()), std::unreachable_sentinel_t>);
+  }
+
+  {
+    std::ranges::iota_view<SomeInt, SomeIntComparable> io(SomeInt(0));
+    assert(std::ranges::next(io.begin(), 10) == io.end());
+  }
+  {
+    static_assert(!std::is_convertible_v<std::ranges::iota_view<SomeInt>, SomeInt>);
+    static_assert( std::is_constructible_v<std::ranges::iota_view<SomeInt>, SomeInt>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/end.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto end() const;
+// constexpr iterator end() const requires same_as<W, Bound>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T, class U>
+constexpr void testType(U u) {
+  {
+    std::ranges::iota_view<T, U> io(T(0), u);
+    assert(std::ranges::next(io.begin(), 10) == io.end());
+  }
+  {
+    std::ranges::iota_view<T, U> io(T(10), u);
+    assert(io.begin() == io.end());
+    assert(io.begin() == std::move(io).end());
+  }
+  {
+    const std::ranges::iota_view<T, U> io(T(0), u);
+    assert(std::ranges::next(io.begin(), 10) == io.end());
+    assert(std::ranges::next(io.begin(), 10) == std::move(io).end());
+  }
+  {
+    const std::ranges::iota_view<T, U> io(T(10), u);
+    assert(io.begin() == io.end());
+  }
+
+  {
+    std::ranges::iota_view<T> io(T(0), std::unreachable_sentinel);
+    assert(io.begin() != io.end());
+    assert(std::ranges::next(io.begin()) != io.end());
+    assert(std::ranges::next(io.begin(), 10) != io.end());
+  }
+  {
+    const std::ranges::iota_view<T> io(T(0), std::unreachable_sentinel);
+    assert(io.begin() != io.end());
+    assert(std::ranges::next(io.begin()) != io.end());
+    assert(std::ranges::next(io.begin(), 10) != io.end());
+  }
+}
+
+constexpr bool test() {
+  testType<SomeInt>(SomeInt(10));
+  testType<SomeInt>(IntComparableWith(SomeInt(10)));
+  testType<signed long>(IntComparableWith<signed long>(10));
+  testType<unsigned long>(IntComparableWith<unsigned long>(10));
+  testType<int>(IntComparableWith<int>(10));
+  testType<int>(int(10));
+  testType<unsigned>(unsigned(10));
+  testType<unsigned>(IntComparableWith<unsigned>(10));
+  testType<short>(short(10));
+  testType<short>(IntComparableWith<short>(10));
+  testType<unsigned short>(IntComparableWith<unsigned short>(10));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/compare.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr bool operator<(const iterator& x, const iterator& y)
+//   requires totally_ordered<W>;
+// friend constexpr bool operator>(const iterator& x, const iterator& y)
+//   requires totally_ordered<W>;
+// friend constexpr bool operator<=(const iterator& x, const iterator& y)
+//   requires totally_ordered<W>;
+// friend constexpr bool operator>=(const iterator& x, const iterator& y)
+//   requires totally_ordered<W>;
+
+// TODO: test spaceship operator once it's implemented.
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  {
+    const std::ranges::iota_view<int> io(0);
+    assert(                  io.begin()  ==                   io.begin() );
+    assert(                  io.begin()  <  std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >                    io.begin() );
+    assert(                  io.begin()  <= std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >=                   io.begin() );
+    assert(                  io.begin()  <=                   io.begin() );
+    assert(                  io.begin()  >=                   io.begin() );
+  }
+  {
+    std::ranges::iota_view<int> io(0);
+    assert(                  io.begin()  ==                   io.begin() );
+    assert(                  io.begin()  <  std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >                    io.begin() );
+    assert(                  io.begin()  <= std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >=                   io.begin() );
+    assert(                  io.begin()  <=                   io.begin() );
+    assert(                  io.begin()  >=                   io.begin() );
+  }
+  {
+    const std::ranges::iota_view<SomeInt> io(SomeInt(0));
+    assert(                  io.begin()  ==                   io.begin() );
+    assert(                  io.begin()  <  std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >                    io.begin() );
+    assert(                  io.begin()  <= std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >=                   io.begin() );
+    assert(                  io.begin()  <=                   io.begin() );
+    assert(                  io.begin()  >=                   io.begin() );
+  }
+  {
+    std::ranges::iota_view<SomeInt> io(SomeInt(0));
+    assert(                  io.begin()  ==                   io.begin() );
+    assert(                  io.begin()  <  std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >                    io.begin() );
+    assert(                  io.begin()  <= std::ranges::next(io.begin()));
+    assert(std::ranges::next(io.begin()) >=                   io.begin() );
+    assert(                  io.begin()  <=                   io.begin() );
+    assert(                  io.begin()  >=                   io.begin() );
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// iterator() requires default_initializable<W> = default;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  using Iter = std::ranges::iterator_t<std::ranges::iota_view<Int42<DefaultTo42>>>;
+  Iter iter;
+  assert((*iter).value_ == 42);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/ctor.value.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit iterator(W value);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  {
+    using Iter = std::ranges::iterator_t<std::ranges::iota_view<int>>;
+    auto iter = Iter(42);
+    assert(*iter == 42);
+  }
+  {
+    using Iter = std::ranges::iterator_t<std::ranges::iota_view<SomeInt>>;
+    auto iter = Iter(SomeInt(42));
+    assert(*iter == SomeInt(42));
+  }
+  {
+    using Iter = std::ranges::iterator_t<std::ranges::iota_view<SomeInt>>;
+    static_assert(!std::is_convertible_v<Iter, SomeInt>);
+    static_assert( std::is_constructible_v<Iter, SomeInt>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/decrement.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator--() requires decrementable<W>;
+// constexpr iterator operator--(int) requires decrementable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class T>
+concept Decrementable =
+  requires(T i) {
+    --i;
+  } ||
+  requires(T i) {
+    i--;
+  };
+
+constexpr bool test() {
+  {
+    std::ranges::iota_view<int> io(0);
+    auto iter1 = std::next(io.begin());
+    auto iter2 = std::next(io.begin());
+    assert(iter1 == iter2);
+    assert(--iter1 != iter2--);
+    assert(iter1 == iter2);
+
+    static_assert(!std::is_reference_v<decltype(iter2--)>);
+    static_assert( std::is_reference_v<decltype(--iter2)>);
+    static_assert(std::same_as<std::remove_reference_t<decltype(--iter2)>, decltype(iter2--)>);
+  }
+  {
+    std::ranges::iota_view io(SomeInt(0));
+    auto iter1 = std::next(io.begin());
+    auto iter2 = std::next(io.begin());
+    assert(iter1 == iter2);
+    assert(--iter1 != iter2--);
+    assert(iter1 == iter2);
+
+    static_assert(!std::is_reference_v<decltype(iter2--)>);
+    static_assert( std::is_reference_v<decltype(--iter2)>);
+    static_assert(std::same_as<std::remove_reference_t<decltype(--iter2)>, decltype(iter2--)>);
+  }
+
+  static_assert(!Decrementable<std::ranges::iota_view<NotDecrementable>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr bool operator==(const iterator& x, const iterator& y)
+//   requires equality_comparable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  {
+    const std::ranges::iota_view<int> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1++;
+    assert(iter1 != iter2);
+    iter2++;
+    assert(iter1 == iter2);
+  }
+  {
+    std::ranges::iota_view<int> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1++;
+    assert(iter1 != iter2);
+    iter2++;
+    assert(iter1 == iter2);
+  }
+  {
+    const std::ranges::iota_view<SomeInt> io(SomeInt(0));
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1++;
+    assert(iter1 != iter2);
+    iter2++;
+    assert(iter1 == iter2);
+  }
+  {
+    std::ranges::iota_view<SomeInt> io(SomeInt(0));
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1++;
+    assert(iter1 != iter2);
+    iter2++;
+    assert(iter1 == iter2);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/increment.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator++();
+// constexpr void operator++(int);
+// constexpr iterator operator++(int) requires incrementable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  {
+    std::ranges::iota_view<int> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(++iter1 != iter2++);
+    assert(iter1 == iter2);
+
+    static_assert(!std::is_reference_v<decltype(iter2++)>);
+    static_assert( std::is_reference_v<decltype(++iter2)>);
+    static_assert(std::same_as<std::remove_reference_t<decltype(++iter2)>, decltype(iter2++)>);
+  }
+  {
+    std::ranges::iota_view io(SomeInt(0));
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(++iter1 != iter2++);
+    assert(iter1 == iter2);
+
+    static_assert(!std::is_reference_v<decltype(iter2++)>);
+    static_assert( std::is_reference_v<decltype(++iter2)>);
+    static_assert(std::same_as<std::remove_reference_t<decltype(++iter2)>, decltype(iter2++)>);
+  }
+
+  {
+    std::ranges::iota_view<NotIncrementable> io(NotIncrementable(0));
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(++iter1 != iter2);
+    iter2++;
+    assert(iter1 == iter2);
+
+    static_assert(std::same_as<decltype(iter2++), void>);
+    static_assert(std::is_reference_v<decltype(++iter2)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/member_typedefs.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Test iterator category and iterator concepts.
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+struct Decrementable {
+  using difference_type = int;
+
+  auto operator<=>(const Decrementable&) const = default;
+
+  constexpr Decrementable& operator++();
+  constexpr Decrementable  operator++(int);
+  constexpr Decrementable& operator--();
+  constexpr Decrementable  operator--(int);
+};
+
+struct Incrementable {
+  using difference_type = int;
+
+  auto operator<=>(const Incrementable&) const = default;
+
+  constexpr Incrementable& operator++();
+  constexpr Incrementable  operator++(int);
+};
+
+struct BigType {
+  char buffer[128];
+
+  using difference_type = int;
+
+  auto operator<=>(const BigType&) const = default;
+
+  constexpr BigType& operator++();
+  constexpr BigType  operator++(int);
+};
+
+struct CharDifferenceType {
+  using difference_type = signed char;
+
+  auto operator<=>(const CharDifferenceType&) const = default;
+
+  constexpr CharDifferenceType& operator++();
+  constexpr CharDifferenceType  operator++(int);
+};
+
+template<class T>
+concept HasIteratorCategory = requires { typename std::ranges::iterator_t<T>::iterator_category; };
+
+using IntDiffT = std::conditional_t<
+  sizeof(int) == sizeof(long),
+  long long,
+  long
+>;
+
+void test() {
+  {
+    const std::ranges::iota_view<char> io(0);
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, char>);
+    static_assert(std::same_as<Iter::difference_type, int>);
+  }
+  {
+    const std::ranges::iota_view<short> io(0);
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, short>);
+    static_assert(std::same_as<Iter::difference_type, int>);
+  }
+  {
+    const std::ranges::iota_view<int> io(0);
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, int>);
+    static_assert(std::same_as<Iter::difference_type, IntDiffT>);
+  }
+  {
+    const std::ranges::iota_view<long> io(0);
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, long>);
+    static_assert(std::same_as<Iter::difference_type, long long>);
+  }
+  {
+    const std::ranges::iota_view<long long> io(0);
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, long long>);
+    static_assert(std::same_as<Iter::difference_type, long long>); // TODO: is this valid? What type should be used here?
+  }
+  {
+    const std::ranges::iota_view<Decrementable> io;
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, Decrementable>);
+    static_assert(std::same_as<Iter::difference_type, int>);
+  }
+  {
+    const std::ranges::iota_view<Incrementable> io;
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, Incrementable>);
+    static_assert(std::same_as<Iter::difference_type, int>);
+  }
+  {
+    const std::ranges::iota_view<NotIncrementable> io(NotIncrementable(0));
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::input_iterator_tag>);
+    static_assert(!HasIteratorCategory<std::ranges::iota_view<NotIncrementable>>);
+    static_assert(std::same_as<Iter::value_type, NotIncrementable>);
+    static_assert(std::same_as<Iter::difference_type, int>);
+  }
+  {
+    const std::ranges::iota_view<BigType> io;
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, BigType>);
+    static_assert(std::same_as<Iter::difference_type, int>);
+  }
+  {
+    const std::ranges::iota_view<CharDifferenceType> io;
+    using Iter = decltype(io.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, CharDifferenceType>);
+    static_assert(std::same_as<Iter::difference_type, signed char>);
+  }
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/minus.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr iterator operator-(iterator i, difference_type n)
+//   requires advanceable<W>;
+// friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+//   requires advanceable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+using IntDiffT = std::conditional_t<
+  sizeof(int) == sizeof(long),
+  long long,
+  long
+>;
+
+constexpr bool test() {
+  // <iterator> - difference_type
+  {
+    // When "_Start" is signed integer like.
+    {
+      std::ranges::iota_view<int> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 == iter2);
+      assert(iter1 - 5 != iter2);
+      assert(iter1 - 5 == std::ranges::prev(iter2, 5));
+
+      static_assert(!std::is_reference_v<decltype(iter2 - 5)>);
+    }
+
+    // When "_Start" is not integer like.
+    {
+      std::ranges::iota_view io(SomeInt(0));
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 == iter2);
+      assert(iter1 - 5 != iter2);
+      assert(iter1 - 5 == std::ranges::prev(iter2, 5));
+
+      static_assert(!std::is_reference_v<decltype(iter2 - 5)>);
+    }
+
+    // When "_Start" is unsigned integer like and n is greater than or equal to zero.
+    {
+      std::ranges::iota_view<unsigned> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 == iter2);
+      assert(iter1 - 5 != iter2);
+      assert(iter1 - 5 == std::ranges::prev(iter2, 5));
+
+      static_assert(!std::is_reference_v<decltype(iter2 - 5)>);
+    }
+    {
+      std::ranges::iota_view<unsigned> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - 0 == iter2);
+    }
+
+    // When "_Start" is unsigned integer like and n is less than zero.
+    {
+      std::ranges::iota_view<unsigned> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - 5 != iter2);
+      assert(iter1 - 5 == std::ranges::prev(iter2, 5));
+
+      static_assert(!std::is_reference_v<decltype(iter2 - 5)>);
+    }
+  }
+
+  // <iterator> - <iterator>
+  {
+    // When "_Start" is signed integer like.
+    {
+      std::ranges::iota_view<int> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 5);
+      assert(iter1 - iter2 == 5);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), IntDiffT>);
+    }
+    {
+      std::ranges::iota_view<int> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - iter2 == 0);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), IntDiffT>);
+    }
+    {
+      std::ranges::iota_view<int> io(0);
+      auto iter1 = std::next(io.begin(), 5);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - iter2 == -5);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), IntDiffT>);
+    }
+
+    // When "_Start" is unsigned integer like and y > x.
+    {
+      std::ranges::iota_view<unsigned> io(0);
+      auto iter1 = std::next(io.begin(), 5);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - iter2 == -5);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), IntDiffT>);
+    }
+
+    // When "_Start" is unsigned integer like and x >= y.
+    {
+      std::ranges::iota_view<unsigned> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 5);
+      assert(iter1 - iter2 == 5);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), IntDiffT>);
+    }
+    {
+      std::ranges::iota_view<unsigned> io(0);
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - iter2 == 0);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), IntDiffT>);
+    }
+
+    // When "_Start" is not integer like.
+    {
+      std::ranges::iota_view io(SomeInt(0));
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 5);
+      assert(iter1 - iter2 == 5);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), int>);
+    }
+    {
+      std::ranges::iota_view io(SomeInt(0));
+      auto iter1 = std::next(io.begin(), 10);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - iter2 == 0);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), int>);
+    }
+    {
+      std::ranges::iota_view io(SomeInt(0));
+      auto iter1 = std::next(io.begin(), 5);
+      auto iter2 = std::next(io.begin(), 10);
+      assert(iter1 - iter2 == -5);
+
+      static_assert(std::same_as<decltype(iter1 - iter2), int>);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/minus_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator-=(difference_type n)
+//   requires advanceable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  // When "_Start" is signed integer like.
+  {
+    std::ranges::iota_view<int> io(0);
+    auto iter1 = std::next(io.begin(), 10);
+    auto iter2 = std::next(io.begin(), 10);
+    assert(iter1 == iter2);
+    iter1 -= 5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::prev(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 -= 5)>);
+  }
+
+  // When "_Start" is not integer like.
+  {
+    std::ranges::iota_view io(SomeInt(0));
+    auto iter1 = std::next(io.begin(), 10);
+    auto iter2 = std::next(io.begin(), 10);
+    assert(iter1 == iter2);
+    iter1 -= 5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::prev(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 -= 5)>);
+  }
+
+  // When "_Start" is unsigned integer like and n is greater than or equal to zero.
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = std::next(io.begin(), 10);
+    auto iter2 = std::next(io.begin(), 10);
+    assert(iter1 == iter2);
+    iter1 -= 5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::prev(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 -= 5)>);
+  }
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = std::next(io.begin(), 10);
+    auto iter2 = std::next(io.begin(), 10);
+    assert(iter1 == iter2);
+    iter1 -= 0;
+    assert(iter1 == iter2);
+  }
+
+  // When "_Start" is unsigned integer like and n is less than zero.
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = std::next(io.begin(), 10);
+    auto iter2 = std::next(io.begin(), 10);
+    assert(iter1 == iter2);
+    iter1 -= -5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 -= -5)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/plus.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr iterator operator+(iterator i, difference_type n)
+//   requires advanceable<W>;
+// friend constexpr iterator operator+(difference_type n, iterator i)
+//   requires advanceable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  // When "_Start" is signed integer like.
+  {
+    std::ranges::iota_view<int> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(iter1 + 5 != iter2);
+    assert(iter1 + 5 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+
+  // When "_Start" is not integer like.
+  {
+    std::ranges::iota_view io(SomeInt(0));
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(iter1 + 5 != iter2);
+    assert(iter1 + 5 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+
+  // When "_Start" is unsigned integer like and n is greater than or equal to zero.
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(iter1 + 5 != iter2);
+    assert(iter1 + 5 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(iter1 + 0 == iter2);
+  }
+
+  // When "_Start" is unsigned integer like and n is less than zero.
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    assert(iter1 + 5 != iter2);
+    assert(iter1 + 5 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/plus_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator+=(difference_type n)
+//   requires advanceable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  // When "_Start" is signed integer like.
+  {
+    std::ranges::iota_view<int> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1 += 5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+
+  // When "_Start" is not integer like.
+  {
+    std::ranges::iota_view io(SomeInt(0));
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1 += 5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+
+  // When "_Start" is unsigned integer like and n is greater than or equal to zero.
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1 += 5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1 += 0;
+    assert(iter1 == iter2);
+  }
+
+  // When "_Start" is unsigned integer like and n is less than zero.
+  {
+    std::ranges::iota_view<unsigned> io(0);
+    auto iter1 = io.begin();
+    auto iter2 = io.begin();
+    assert(iter1 == iter2);
+    iter1 += 5;
+    assert(iter1 != iter2);
+    assert(iter1 == std::ranges::next(iter2, 5));
+
+    static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/star.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+struct NotNoexceptCopy {
+  using difference_type = int;
+
+  int value_;
+  constexpr explicit NotNoexceptCopy(int value = 0) : value_(value) {}
+  NotNoexceptCopy(const NotNoexceptCopy&) noexcept(false) = default;
+
+  bool operator==(const NotNoexceptCopy&) const = default;
+
+  friend constexpr NotNoexceptCopy& operator+=(NotNoexceptCopy &lhs, const NotNoexceptCopy& rhs) {
+    lhs.value_ += rhs.value_; return lhs;
+  }
+  friend constexpr NotNoexceptCopy& operator-=(NotNoexceptCopy &lhs, const NotNoexceptCopy& rhs) {
+    lhs.value_ -= rhs.value_; return lhs;
+  }
+
+  friend constexpr NotNoexceptCopy operator+(NotNoexceptCopy lhs, NotNoexceptCopy rhs) {
+    return NotNoexceptCopy{lhs.value_ + rhs.value_};
+  }
+  friend constexpr int operator-(NotNoexceptCopy lhs, NotNoexceptCopy rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+
+  constexpr NotNoexceptCopy& operator++()     { ++value_; return *this; }
+  constexpr void              operator++(int) { ++value_;               }
+};
+
+template<class T>
+constexpr void testType() {
+  {
+    std::ranges::iota_view<T> io(T(0));
+    auto iter = io.begin();
+    for (int i = 0; i < 100; ++i, ++iter)
+      assert(*iter == T(i));
+
+    static_assert(noexcept(*iter) == !std::same_as<T, NotNoexceptCopy>);
+  }
+  {
+    std::ranges::iota_view<T> io(T(10));
+    auto iter = io.begin();
+    for (int i = 10; i < 100; ++i, ++iter)
+      assert(*iter == T(i));
+  }
+  {
+    const std::ranges::iota_view<T> io(T(0));
+    auto iter = io.begin();
+    for (int i = 0; i < 100; ++i, ++iter)
+      assert(*iter == T(i));
+  }
+  {
+    const std::ranges::iota_view<T> io(T(10));
+    auto iter = io.begin();
+    for (int i = 10; i < 100; ++i, ++iter)
+      assert(*iter == T(i));
+  }
+}
+
+constexpr bool test() {
+  testType<SomeInt>();
+  testType<NotNoexceptCopy>();
+  testType<signed long>();
+  testType<unsigned long>();
+  testType<int>();
+  testType<unsigned>();
+  testType<short>();
+  testType<unsigned short>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/subscript.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr W operator[](difference_type n) const
+//   requires advanceable<W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class T>
+constexpr void testType() {
+  {
+    std::ranges::iota_view<T> io(T(0));
+    auto iter = io.begin();
+    for (int i = 0; i < 100; ++i)
+      assert(iter[i] == T(i));
+  }
+  {
+    std::ranges::iota_view<T> io(T(10));
+    auto iter = io.begin();
+    for (int i = 0; i < 100; ++i)
+      assert(iter[i] == T(i + 10));
+  }
+  {
+    const std::ranges::iota_view<T> io(T(0));
+    auto iter = io.begin();
+    for (int i = 0; i < 100; ++i)
+      assert(iter[i] == T(i));
+  }
+  {
+    const std::ranges::iota_view<T> io(T(10));
+    auto iter = io.begin();
+    for (int i = 0; i < 100; ++i)
+      assert(iter[i] == T(i + 10));
+  }
+}
+
+constexpr bool test() {
+  testType<SomeInt>();
+  testType<signed long>();
+  testType<unsigned long>();
+  testType<int>();
+  testType<unsigned>();
+  testType<short>();
+  testType<unsigned short>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// sentinel() = default;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  using Sent = std::ranges::sentinel_t<std::ranges::iota_view<Int42<DefaultTo42>, IntComparableWith<Int42<DefaultTo42>>>>;
+  using Iter = std::ranges::iterator_t<std::ranges::iota_view<Int42<DefaultTo42>, IntComparableWith<Int42<DefaultTo42>>>>;
+  assert(Sent() == Iter());
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/ctor.value.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit sentinel(Bound bound);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  {
+    using Sent = std::ranges::sentinel_t<std::ranges::iota_view<int, IntSentinelWith<int>>>;
+    using Iter = std::ranges::iterator_t<std::ranges::iota_view<int, IntSentinelWith<int>>>;
+    auto sent = Sent(IntSentinelWith<int>(42));
+    assert(sent == Iter(42));
+  }
+  {
+    using Sent = std::ranges::sentinel_t<std::ranges::iota_view<SomeInt, IntSentinelWith<SomeInt>>>;
+    using Iter = std::ranges::iterator_t<std::ranges::iota_view<SomeInt, IntSentinelWith<SomeInt>>>;
+    auto sent = Sent(IntSentinelWith<SomeInt>(SomeInt(42)));
+    assert(sent == Iter(SomeInt(42)));
+  }
+  {
+    using Sent = std::ranges::sentinel_t<std::ranges::iota_view<SomeInt, IntSentinelWith<SomeInt>>>;
+    static_assert(!std::is_convertible_v<Sent, IntSentinelWith<SomeInt>>);
+    static_assert( std::is_constructible_v<Sent, IntSentinelWith<SomeInt>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr bool operator==(const iterator& x, const sentinel& y);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  {
+    const std::ranges::iota_view<int, IntComparableWith<int>> io(0, IntComparableWith<int>(10));
+    auto iter = io.begin();
+    auto sent = io.end();
+    assert(iter != sent);
+    assert(iter + 10 == sent);
+  }
+  {
+    std::ranges::iota_view<int, IntComparableWith<int>> io(0, IntComparableWith<int>(10));
+    auto iter = io.begin();
+    auto sent = io.end();
+    assert(iter != sent);
+    assert(iter + 10 == sent);
+  }
+  {
+    const std::ranges::iota_view io(SomeInt(0), IntComparableWith(SomeInt(10)));
+    auto iter = io.begin();
+    auto sent = io.end();
+    assert(iter != sent);
+    assert(iter + 10 == sent);
+  }
+  {
+    std::ranges::iota_view io(SomeInt(0), IntComparableWith(SomeInt(10)));
+    auto iter = io.begin();
+    auto sent = io.end();
+    assert(iter != sent);
+    assert(iter + 10 == sent);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr iter_difference_t<W> operator-(const iterator& x, const sentinel& y)
+//   requires sized_­sentinel_­for<Bound, W>;
+// friend constexpr iter_difference_t<W> operator-(const sentinel& x, const iterator& y)
+//   requires sized_­sentinel_­for<Bound, W>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "../types.h"
+
+template<class T>
+concept MinusInvocable = requires(std::ranges::iota_view<T, IntSentinelWith<T>> io) {
+  io.end() - io.begin();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    auto outIter = random_access_iterator<int*>(buffer);
+    std::ranges::iota_view<random_access_iterator<int*>, IntSentinelWith<random_access_iterator<int*>>> io(
+      outIter, IntSentinelWith<random_access_iterator<int*>>(std::ranges::next(outIter, 8)));
+    auto iter = io.begin();
+    auto sent = io.end();
+    assert(iter - sent == -8);
+    assert(sent - iter == 8);
+  }
+  {
+    auto outIter = random_access_iterator<int*>(buffer);
+    const std::ranges::iota_view<random_access_iterator<int*>, IntSentinelWith<random_access_iterator<int*>>> io(
+      outIter, IntSentinelWith<random_access_iterator<int*>>(std::ranges::next(outIter, 8)));
+    const auto iter = io.begin();
+    const auto sent = io.end();
+    assert(iter - sent == -8);
+    assert(sent - iter == 8);
+  }
+
+  {
+    // This is odd, see the comment below.
+    static_assert(!MinusInvocable<int>);
+  }
+
+// TODO: it seems odd that this is the *only* place we are required to have an input_or_output_iterator.
+// Example: https://godbolt.org/z/WGc9xoqcb
+//   {
+//     const std::ranges::iota_view<int, IntSentinelWith<int>> io(0, IntSentinelWith<int>(10));
+//     auto iter = io.begin();
+//     auto sent = io.end();
+//     assert(iter - sent == -10);
+//     assert(sent - iter == 10);
+//   }
+//   {
+//     std::ranges::iota_view<int, IntSentinelWith<int>> io(0, IntSentinelWith<int>(10));
+//     auto iter = io.begin();
+//     auto sent = io.end();
+//     assert(iter - sent == -10);
+//     assert(sent - iter == 10);
+//   }
+//   {
+//     const std::ranges::iota_view io(SomeInt(0), IntSentinelWith(SomeInt(10)));
+//     auto iter = io.begin();
+//     auto sent = io.end();
+//     assert(iter - sent == -10);
+//     assert(sent - iter == 10);
+//   }
+//   {
+//     std::ranges::iota_view io(SomeInt(0), IntSentinelWith(SomeInt(10)));
+//     auto iter = io.begin();
+//     auto sent = io.end();
+//     assert(iter - sent == -10);
+//     assert(sent - iter == 10);
+//   }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/size.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto size() const requires see below;
+
+#include <ranges>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  // Both are integer like and both are less than zero.
+  {
+    const std::ranges::iota_view<int, int> io(-10, -5);
+    assert(io.size() == 5);
+  }
+  {
+    const std::ranges::iota_view<int, int> io(-10, -10);
+    assert(io.size() == 0);
+  }
+
+  // Both are integer like and "value_" is less than zero.
+  {
+    const std::ranges::iota_view<int, int> io(-10, 10);
+    assert(io.size() == 20);
+  }
+  {
+    const std::ranges::iota_view<int, int> io(std::numeric_limits<int>::min(), std::numeric_limits<int>::max());
+    assert(io.size() == (static_cast<unsigned>(std::numeric_limits<int>::max()) * 2) + 1);
+  }
+
+  // It is UB for "bound_" to be less than "value_" i.e.: iota_view<int, int> io(10, -5).
+
+  // Both are integer like and neither less than zero.
+  {
+    const std::ranges::iota_view<int, int> io(10, 20);
+    assert(io.size() == 10);
+  }
+  {
+    const std::ranges::iota_view<int, int> io(10, 10);
+    assert(io.size() == 0);
+  }
+  {
+    const std::ranges::iota_view<int, int> io(0, 0);
+    assert(io.size() == 0);
+  }
+  {
+    const std::ranges::iota_view<int, int> io(0, std::numeric_limits<int>::max());
+    assert(io.size() == std::numeric_limits<int>::max());
+  }
+
+  // Neither are integer like.
+  {
+    const std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(-20), SomeInt(-10));
+    assert(io.size() == 10);
+  }
+  {
+    const std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(-10), SomeInt(-10));
+    assert(io.size() == 0);
+  }
+  {
+    const std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(0), SomeInt(0));
+    assert(io.size() == 0);
+  }
+  {
+    const std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(10), SomeInt(20));
+    assert(io.size() == 10);
+  }
+  {
+    const std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(10), SomeInt(10));
+    assert(io.size() == 0);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+//   static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.iota.view/type.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+#include <ranges>
+
+// Test that we SFINAE away iota_view<bool>.
+
+template<class T> std::ranges::iota_view<T> f(int);
+template<class T> void f(...);
+
+void test() {
+  f<bool>(42);
+}

libcxx/test/std/ranges/range.factories/range.iota.view/types.h

+#ifndef TEST_STD_RANGES_RANGE_FACTORIES_RANGE_IOTA_VIEW_TYPES_H
+#define TEST_STD_RANGES_RANGE_FACTORIES_RANGE_IOTA_VIEW_TYPES_H
+
+#include "test_macros.h"
+
+struct SomeInt {
+  using difference_type = int;
+
+  int value_;
+  constexpr explicit SomeInt(int value = 0) : value_(value) {}
+
+  auto operator<=>(const SomeInt&) const = default;
+
+  friend constexpr SomeInt& operator+=(SomeInt &lhs, const SomeInt& rhs) {
+    lhs.value_ += rhs.value_; return lhs;
+  }
+  friend constexpr SomeInt& operator-=(SomeInt &lhs, const SomeInt& rhs) {
+    lhs.value_ -= rhs.value_; return lhs;
+  }
+
+  friend constexpr SomeInt& operator+=(SomeInt &lhs, difference_type rhs) {
+    lhs.value_ += rhs; return lhs;
+  }
+  friend constexpr SomeInt& operator-=(SomeInt &lhs, difference_type rhs) {
+    lhs.value_ -= rhs; return lhs;
+  }
+
+  friend constexpr SomeInt operator+(SomeInt lhs, SomeInt rhs) {
+    return SomeInt{lhs.value_ + rhs.value_};
+  }
+  friend constexpr int operator-(SomeInt lhs, SomeInt rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+
+  friend constexpr SomeInt operator+(SomeInt lhs, difference_type rhs) {
+    return SomeInt{lhs.value_ + rhs};
+  }
+  friend constexpr int operator-(SomeInt lhs, difference_type rhs) {
+    return lhs.value_ - rhs;
+  }
+
+  friend constexpr SomeInt operator+(difference_type lhs, SomeInt rhs) {
+    return SomeInt{lhs + rhs.value_};
+  }
+  friend constexpr int operator-(difference_type lhs, SomeInt rhs) {
+    return lhs - rhs.value_;
+  }
+
+  constexpr SomeInt& operator++() { ++value_; return *this; }
+  constexpr SomeInt  operator++(int) { auto tmp = *this; ++value_; return tmp; }
+  constexpr SomeInt& operator--() { --value_; return *this; }
+  constexpr SomeInt  operator--(int) { auto tmp = *this; --value_; return tmp; }
+};
+
+template<class T>
+struct IntComparableWith {
+  using difference_type = std::iter_difference_t<T>;
+
+  T value_;
+  constexpr explicit IntComparableWith(T value = T()) : value_(value) {}
+
+  friend constexpr bool operator==(IntComparableWith lhs, IntComparableWith rhs) {
+    return lhs.value_ == rhs.value_;
+  }
+  friend constexpr bool operator==(IntComparableWith lhs, T rhs) {
+    return lhs.value_ == rhs;
+  }
+  friend constexpr bool operator==(T lhs, IntComparableWith rhs) {
+    return lhs == rhs.value_;
+  }
+
+  friend constexpr IntComparableWith operator+(IntComparableWith lhs, IntComparableWith rhs) {
+    return IntComparableWith{lhs.value_ + rhs.value_};
+  }
+  friend constexpr difference_type operator-(IntComparableWith lhs, IntComparableWith rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+
+  constexpr IntComparableWith& operator++() { ++value_; return *this; }
+  constexpr IntComparableWith  operator++(int) { auto tmp = *this; ++value_; return tmp; }
+  constexpr IntComparableWith  operator--() { --value_; return *this; }
+};
+
+template<class T>
+struct IntSentinelWith {
+  using difference_type = std::iter_difference_t<T>;
+
+  T value_;
+  constexpr explicit IntSentinelWith(T value = T()) : value_(value) {}
+
+  friend constexpr bool operator==(IntSentinelWith lhs, IntSentinelWith rhs) {
+    return lhs.value_ == rhs.value_;
+  }
+  friend constexpr bool operator==(IntSentinelWith lhs, T rhs) {
+    return lhs.value_ == rhs;
+  }
+  friend constexpr bool operator==(T lhs, IntSentinelWith rhs) {
+    return lhs == rhs.value_;
+  }
+
+  friend constexpr IntSentinelWith operator+(IntSentinelWith lhs, IntSentinelWith rhs) {
+    return IntSentinelWith{lhs.value_ + rhs.value_};
+  }
+  friend constexpr difference_type operator-(IntSentinelWith lhs, IntSentinelWith rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+  friend constexpr difference_type operator-(IntSentinelWith lhs, T rhs) {
+    return lhs.value_ - rhs;
+  }
+  friend constexpr difference_type operator-(T lhs, IntSentinelWith rhs) {
+    return lhs - rhs.value_;
+  }
+
+  constexpr IntSentinelWith& operator++() { ++value_; return *this; }
+  constexpr IntSentinelWith  operator++(int) { auto tmp = *this; ++value_; return tmp; }
+  constexpr IntSentinelWith  operator--() { --value_; return *this; }
+};
+
+struct NotIncrementable {
+  using difference_type = int;
+
+  int value_;
+  constexpr explicit NotIncrementable(int value = 0) : value_(value) {}
+
+  bool operator==(const NotIncrementable&) const = default;
+
+  friend constexpr NotIncrementable& operator+=(NotIncrementable &lhs, const NotIncrementable& rhs) {
+    lhs.value_ += rhs.value_; return lhs;
+  }
+  friend constexpr NotIncrementable& operator-=(NotIncrementable &lhs, const NotIncrementable& rhs) {
+    lhs.value_ -= rhs.value_; return lhs;
+  }
+
+  friend constexpr NotIncrementable operator+(NotIncrementable lhs, NotIncrementable rhs) {
+    return NotIncrementable{lhs.value_ + rhs.value_};
+  }
+  friend constexpr int operator-(NotIncrementable lhs, NotIncrementable rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+
+  constexpr NotIncrementable& operator++()    { ++value_; return *this; }
+  constexpr void              operator++(int) { ++value_;               }
+  constexpr NotIncrementable& operator--()    { --value_; return *this; }
+};
+static_assert(!std::incrementable<NotIncrementable>);
+
+struct NotDecrementable {
+  using difference_type = int;
+
+  int value_;
+  constexpr explicit NotDecrementable(int value = 0) : value_(value) {}
+
+  bool operator==(const NotDecrementable&) const = default;
+
+  friend constexpr NotDecrementable& operator+=(NotDecrementable &lhs, const NotDecrementable& rhs) {
+    lhs.value_ += rhs.value_; return lhs;
+  }
+  friend constexpr NotDecrementable& operator-=(NotDecrementable &lhs, const NotDecrementable& rhs) {
+    lhs.value_ -= rhs.value_; return lhs;
+  }
+
+  friend constexpr NotDecrementable operator+(NotDecrementable lhs, NotDecrementable rhs) {
+    return NotDecrementable{lhs.value_ + rhs.value_};
+  }
+  friend constexpr int operator-(NotDecrementable lhs, NotDecrementable rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+
+  constexpr NotDecrementable& operator++()    { ++value_; return *this; }
+  constexpr void              operator++(int) { ++value_;               }
+};
+
+enum CtorKind { DefaultTo42, ValueCtor };
+
+template<CtorKind CK>
+struct Int42 {
+  using difference_type = int;
+
+  int value_;
+  constexpr explicit Int42(int value) : value_(value) {}
+  constexpr explicit Int42() requires (CK == DefaultTo42)
+    : value_(42) {}
+
+  bool operator==(const Int42&) const = default;
+
+  friend constexpr Int42& operator+=(Int42 &lhs, const Int42& rhs) {
+    lhs.value_ += rhs.value_; return lhs;
+  }
+  friend constexpr Int42& operator-=(Int42 &lhs, const Int42& rhs) {
+    lhs.value_ -= rhs.value_; return lhs;
+  }
+
+  friend constexpr Int42 operator+(Int42 lhs, Int42 rhs) {
+    return Int42{lhs.value_ + rhs.value_};
+  }
+  friend constexpr int operator-(Int42 lhs, Int42 rhs) {
+    return lhs.value_ - rhs.value_;
+  }
+
+  constexpr Int42& operator++()    { ++value_; return *this; }
+  constexpr void   operator++(int) { ++value_;               }
+};
+
+#endif // TEST_STD_RANGES_RANGE_FACTORIES_RANGE_IOTA_VIEW_TYPES_H

libcxx/test/std/ranges/range.factories/range.iota.view/views_iota.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// views::iota
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T, class U>
+constexpr void testType(U u) {
+  // Test that this generally does the right thing.
+  // Test with only one argument.
+  {
+    assert(*std::views::iota(T(0)).begin() == T(0));
+  }
+  {
+    const auto io = std::views::iota(T(10));
+    assert(*io.begin() == T(10));
+  }
+  // Test with two arguments.
+  {
+    assert(*std::views::iota(T(0), u).begin() == T(0));
+  }
+  {
+    const auto io = std::views::iota(T(10), u);
+    assert(*io.begin() == T(10));
+  }
+  // Test that we return the correct type.
+  {
+    ASSERT_SAME_TYPE(decltype(std::views::iota(T(10))), std::ranges::iota_view<T>);
+    ASSERT_SAME_TYPE(decltype(std::views::iota(T(10), u)), std::ranges::iota_view<T, U>);
+  }
+  // Test that this is semiregular.
+  // Note: we cannot test perfect forwarding because both T and U must be copyable.
+  {
+    static_assert(std::semiregular<std::remove_const_t<decltype(std::views::iota)>>);
+  }
+}
+
+constexpr bool test() {
+  testType<SomeInt>(SomeInt(10));
+  testType<SomeInt>(IntComparableWith(SomeInt(10)));
+  testType<signed long>(IntComparableWith<signed long>(10));
+  testType<unsigned long>(IntComparableWith<unsigned long>(10));
+  testType<int>(IntComparableWith<int>(10));
+  testType<int>(int(10));
+  testType<unsigned>(unsigned(10));
+  testType<unsigned>(IntComparableWith<unsigned>(10));
+  testType<short>(short(10));
+  testType<short>(IntComparableWith<short>(10));
+  testType<unsigned short>(IntComparableWith<unsigned short>(10));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}