[libcxx][ranges] Adds `common_iterator`.

[zoecarver]

• Diff on correct commit.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

99

Note: all of these constexprs aren't required by the standard, but I'm filing an lwg issue for it.

[zoecarver]

Remove unneeded comment.

[cjdb]

libcxx/include/__iterator/common_iterator.h

99

Please link the issue in this PR before submitting (it doesn't need to be in the patch itself).

[zoecarver]

Update the status document.

[cjdb]

libcxx/include/__iterator/common_iterator.h

41–43

Default sentinel deserves its own (tiny) patch.

[tcanens]

libcxx/include/__iterator/common_iterator.h

52

This isn't going to work if either of them has a non-trivial special member function.

The exposition-only variant really solved a lot of problems in the specification that this will need to solve again.

[zoecarver]

• I think I adressed all the review comments that apply from the other two views. (If not, sorry, let me know and I'll fix them here too.)
• I'm going to update common_iterator to use variant. Because it's not yet constexpr, I'm just going to comment out the static_assert in all the tests. This makes us support closer to the standard anyway. Note: I have not done this yet because it requries fixing a dependency cycle between iterator -> array -> variant -> iterator.

[zoecarver]

libcxx/test/std/iterators/predef.iterators/iterators.common/members.pass.cpp

1 ↗

(On Diff #356841)

Oops, I can delete this now that it's tested elsewhere.

libcxx/test/support/test_iterators.h

164 ↗

(On Diff #356841)

I think this will be a very helpful type to have now that we need to test the default constructibility of all our views/iterators.

[ldionne]

libcxx/include/__iterator/common_iterator.h

33–41

Reminder that this should be using std::variant.

99

I think we should not make them constexpr until the LWG issue has been accepted and resolved. I strongly suspect the reason why they are not constexpr is that the type is expected to use variant, which isn't constexpr yet. You can structure the tests so that constexpr is easy to test when we add it, but please don't add it in the implementation yet.

115

http://eel.is/c++draft/iterators.common#common.iter.nav-5 says:

Otherwise, if requires (I& i) { { *i++ } -> can-reference; } is true or constructible_­from<iter_­value_­t<I>, iter_­reference_­t<I>> && move_­constructible<iter_­value_­t<I>> is false, equivalent to: return get<I>(v_)++;

We're missing && move_constructible<...> here?

118

This should be __postfix_proxy __p(**this); (double-dereference to get the value pointed-to by the iterator).

It also means you have a hole in your coverage since your tests were passing, i.e. this branch of the if constexpr was never exercised. Please make sure all branches of the if constexpr are exercised (here and in operator-> above too).

libcxx/test/std/iterators/predef.iterators/iterators.common/arrow.pass.cpp

26 ↗

(On Diff #356841)

Here and for operator++(int), I'd like you to explicitly call out which part is testing each sub-bullet in the spec (which maps to the if constexpr in the implementation).

libcxx/test/std/iterators/predef.iterators/iterators.common/assign.pass.cpp

30 ↗

(On Diff #356841)

You have a typo in sentienl_type.

libcxx/test/support/test_iterators.h

164 ↗

(On Diff #356841)

I agree, but I would instead call it something like non_default_constructible_iterator. Or whatever you prefer, but I think it's important for the name to reflect the fact that it's an iterator.

170 ↗

(On Diff #356841)

Shouldn't this be std::iterator_traits<It>::iterator_category? Actually, we could perhaps do this instead:

template<class It>
struct std::iterator_traits<no_default_constructor<It>> : std::iterator_traits<It> { };

Then, could we simply drop all the typedefs in no_default_constructor?

[zoecarver]

libcxx/include/__iterator/common_iterator.h

115

Good catch. It looks like this was recently changed.

118

Yes.. you're right. I thought that value_iterator was testing this, but apparently not.

I guess the type I need here is one where i is a __referenceable iterator and ++i is a __referenceable iterator, but i++ is void or something? Arg. OK.

libcxx/test/support/test_iterators.h

170 ↗

(On Diff #356841)

No, because we only provide members such that this is a forward iterator. For example, this is used mostly with pointer types. If we did what you're suggesting these would report that they were contiguous_iterators, but they are not (they're not even bidirectional).

[• Quuxplusone]

libcxx/test/support/test_iterators.h

170 ↗

(On Diff #356841)

Turn this inside out.

template<class T>
class NonDefCtablePtr {
    T *p_;
public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    [...]
    constexpr NonDefCtablePtr(T *p) : p_(p) {}
    constexpr T& operator*() const { return *p_; }
    [...]
    friend constexpr T *base(NonDefCtablePtr p) { return p.p_; }
};

and then in your test cases, use

#include "test_iterator.h"

test<bidirectional_iterator<int*>>();  // bidirectional, default-constructible
test<bidirectional_iterator<NonDefCtablePtr<int>>>();  // bidirectional, non-default-constructible

That is, we already have the iterator wrapper types in order to "downgrade" int* to forward/bidirectional/random-access level. So your NonDefCtable type should not "downgrade." It should just be contiguous, and then if someone wants a downgraded version, they can wrap it in one of the downgrade wrappers.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

115

OK I added a test, but I'd like someone to verify it's correct. See my other comment.

[zoecarver]

Apply review comments.

[zoecarver]

Rebase.

[zoecarver]

libcxx/test/std/iterators/predef.iterators/iterators.common/plus_plus.pass.cpp

87 ↗

(On Diff #357392)

@tcanens and others, is this correct? It seems like this goes against the other logic here (isn't the whole point to make sure that operator++ always returns a referencable type)?

[tcanens]

libcxx/include/__iterator/common_iterator.h

41

Missing move here.

54

Missing forward here.

71

variant does not have heterogeneous conversions of this sort.

77

Likewise.

80–83

It's undefined if it is holding the wrong type, so the check-and-throw get performs is unnecessary (and hurts performance). There should be a way to avoid such checks.

124

__y's sentinel type is _S2, not _Sent. Ditto below.

There seems to be a lack of test coverage here.

libcxx/test/std/iterators/predef.iterators/iterators.common/plus_plus.pass.cpp

87 ↗

(On Diff #357392)

Yes, common_iterator does its best to return something from postfix ++ that meets the C++17 input iterator requirements.

But hitting this case means that it doesn't know a way to produce anything meaningful, so it just gives up.

libcxx/test/support/test_iterators.h

171 ↗

(On Diff #357392)

Something that's not default constructible can't be anything more than input.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

54

Why not move this one too?

libcxx/test/support/test_iterators.h

170 ↗

(On Diff #356841)

Not doing this because of Tim's comment. This is now an input iterator.

[zoecarver]

Apply Tim's comments and add a few more tests.

Thanks Tim!

[zoecarver]

Rebase.

[tcanens]

libcxx/include/__iterator/common_iterator.h

54

They are really both forwards; the difference is that operator->'s proxy only gets used when iter_reference_t<I> isn't a reference, so that forward ends up being a move.

[ldionne]

Comments per the over-the-shoulder review we just did.

libcxx/include/__iterator/common_iterator.h

31–38

This should be defined in <variant>.

Also, I would word the comment differently (because assertions are disabled in most builds):

__unchecked_get is the same as std::get, except, it is UB to use it with the wrong type [...]

92

I'm pretty sure this shouldn't even compile since we're passing the runtime __other.__hold_.index() as a non-type template argument, which expects a constant expression. This means that this isn't tested.

I can think of two ways of implementing this. First (pseudo-code):

__hold_([]() -> variant<_Iter, _Sent> {
  if (__other.__hold_.index() == 0) return {in_place_index<0>, __other.__hold_};
  else                                               return {in_place_index<1>, __other.__hold_};
  _LIBCPP_UNREACHABLE();
}())

The second way would be to use variant<monostate, _Iter, _Sent> and to "default-construct" the monostate when entering this constructor, and then do the if-else dance above in the constructor body. Otherwise, we'll have to default-construct one of the variant alternatives, which we don't want to do (BTW it would be awesome if you could add a test for that).

Pinging @mpark in case he has better ideas.

97

Could we add _LIBCPP_ASSERT(!__other.__hold_­.valueless_­by_­exception()) here since it's a precondition in the spec? Also in the other places where it applies.

99

This should be std::get<index>(__hold_) = std::get<index>(__other.__hold_);.

101

This is going to have the same problem as above, it won't compile. That means there's also a hole in our test coverage.

[ldionne]

libcxx/include/__iterator/common_iterator.h

105

Maybe add _LIBCPP_ASSERT(_VSTD::holds_­alternative<_Iter>(__hold_))?

114

Could you break that { onto a different line? It's kind of hard to see where the requires end and the function body begins.

145

Can we hoist the value of xxxx.index() into local variables? (here and below)

156

Please make sure you test all the branches below (here and in the other functions below too).

202–204

This would fit nicely on a single line IMO.

libcxx/test/std/iterators/predef.iterators/iterators.common/iterator_traits.compile.pass.cpp

56 ↗

(On Diff #358021)

This doesn't look right. According to the spec (http://eel.is/c++draft/iterators.common#common.iter.types-1.3), this should either be the type of operator->() or void, but never Iter const&. This means you most likely have a bug in the implementation.

Also, please add a test where pointer ends up being void.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

156

Added a few tests. Have verified all paths are taken.

libcxx/test/std/iterators/predef.iterators/iterators.common/iterator_traits.compile.pass.cpp

56 ↗

(On Diff #358021)

This doesn't look right. According to the spec (http://eel.is/c++draft/iterators.common#common.iter.types-1.3), this should either be the type of operator->() or void, but never Iter const&. This means you most likely have a bug in the implementation.

Turns out this is actually correct. This is supposed to be the return type of common_iterator's operator->(). And if _Iter has an operator->() then it's supposed to simply return get<Iter>(v). (However, I'd argue that should maybe return get<Iter>(v).operator->(), if you agree, maybe I'll file an LWG issue.)

Sound good now? This threw me off too :P

56 ↗

(On Diff #358021)

Also, please add a test where pointer ends up being void.

Done.

[zoecarver]

Apply Louis' comments.

libcxx/include/__iterator/common_iterator.h

220

@cjdb thanks for helping me figure this one out :)

[tcanens]

libcxx/test/std/iterators/predef.iterators/iterators.common/iterator_traits.compile.pass.cpp

56 ↗

(On Diff #358021)

This doesn't look right. According to the spec (http://eel.is/c++draft/iterators.common#common.iter.types-1.3), this should either be the type of operator->() or void, but never Iter const&. This means you most likely have a bug in the implementation.

Turns out this is actually correct. This is supposed to be the return type of common_iterator's operator->(). And if _Iter has an operator->() then it's supposed to simply return get<Iter>(v). (However, I'd argue that should maybe return get<Iter>(v).operator->(), if you agree, maybe I'll file an LWG issue.)

Producing decltype(a.operator->()) matches http://eel.is/c++draft/iterator.traits#1.sentence-3 but not the actual wording in http://eel.is/c++draft/iterators.common#common.iter.types-1.3 which says that it is the type of a.operator->(), aka remove_reference_t<decltype(a.operator->())>. What's the intent here @CaseyCarter?

[tcanens]

libcxx/include/__iterator/common_iterator.h

97

These should look at __other_idx - this assignment is valid even if *this is valueless.

272–274

This conditional_t seems unnecessary?

[ldionne]

libcxx/include/__iterator/common_iterator.h

78

This should be in the lambda above for it to trigger before we try to access __other.__hold_ unchecked.

92

I think you want _VSTD::__unchecked_get here and elsewhere.

97

Can you add a test where you assign to a common_iterator with a valueless_by_exception() variant?

107

As discussed live: we can use a better message here.

169

How is this behavior really what we want? IIUC, that means that if you compare two common_iterators that both contain different iterators (say It1 and It2) that are not comparable to each other, the common_iterators will compare equal to each other even if It1 and It2 are "pointing" to entirely different elements. Am I misunderstanding something here, or that's an incredibly subtle (and broken) behavior to have at runtime? @tcanens Can you shed some light on this?

In all cases, we need a test where we exercise that.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

40

Add a comment: "iter_reference_t" is never a reference here because if it is we catch it in the if constexpr branch above where this one is called.

107

This should say something like "common_iterator not holding an iterator (holding a sentinel) must hold iterator."

169

We should assert these aren't both zero, even though it's non-conforming, people will thank us.

[tcanens]

libcxx/include/__iterator/common_iterator.h

169

This is meant for C++20 input iterators that aren't comparable with each other. Because incrementing an input iterator invalidates all copies, you can't have two valid iterators pointing to different elements in the same range.

We should assert these aren't both zero, even though it's non-conforming, people will thank us.

Please don't. i == i had better work.

[CaseyCarter]

libcxx/test/std/iterators/predef.iterators/iterators.common/iterator_traits.compile.pass.cpp

56 ↗

(On Diff #358021)

http://eel.is/c++draft/iterator.traits#1.sentence-3 is authoritative; http://eel.is/c++draft/iterators.common#common.iter.types-1.3 should be corrected to agree. Presumably the writer of the latter paragraph was under the impression that a.operator->() is always a prvalue.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

169

This is meant for C++20 input iterators that aren't comparable with each other. Because incrementing an input iterator invalidates all copies, you can't have two valid iterators pointing to different elements in the same range.

Shouldn't this assert (or require) that these are input iterators then?

Please don't. i == i had better work.

But this is not i == i, it's x == y. What you're saying makes sense for input iterators, but what about forward iterators, or even contiguous iterators?

(Thanks for all the help with interpreting the standard's wording here, by the way.)

[tcanens]

libcxx/include/__iterator/common_iterator.h

169

common_iterator is a C++17 compatibility shim. I don't think this is worse than returning true when both are sentinels - two sentinels can mean completely different things, even if they have the same type.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

169

common_iterator is a C++17 compatibility shim. I don't think this is worse than returning true when both are sentinels - two sentinels can mean completely different things, even if they have the same type.

The difference is sentinels must always be the end of the range. I can get behind saying "this must always be true because the sentinels must always be the end of the same range which must be the same element." The part I'm having trouble with is it's OK to have two different forward iterators that point to the same range in different places. Those should return false when compared (or somehow generate an error or UB).

[zoecarver]

Apply remaining few review comments :)

libcxx/include/__iterator/common_iterator.h

169

In all cases, we need a test where we exercise that.

Tested in both assign.pass.cpp (line 35, 50, 68, 74) and eq.pass.cpp (line 78, 88, 89).

[• Quuxplusone]

libcxx/include/__iterator/common_iterator.h

169

I'd prefer to see an explicit static_assert here:

static_assert(!equality_comparable_with<_Iter, _I2>);
return true;

I think this assertion would sufficiently explain why we aren't checking i1 == i2 here — it's because we physically can't. Also, the assertion serves as an important backstop against subsumption bugs. The absolute worst thing that could happen here is that the constraint on line 179 bit-rots under maintenance and we end up executing this code for iterators that are comparable.

173

_VSTD::__unchecked_get<0>(__x.__hold_) == _VSTD::__unchecked_get<1>(__y.__hold_)

I don't trust __unchecked_get<_Iter> to do the right thing when _Sent is cvref-qualified _Iter or vice versa (or they're in some other subtle corner-case way related to each other). Integer indices, on the other hand, are nice and solid and trustworthy. Also, cppreference documents that the code should use get<i> and get<j>, not get<I> and get<S2>; it's just barely possible that there might be a technical reason for that.

[tcanens]

libcxx/include/__iterator/common_iterator.h

169

forward iterators are required to be comparable, so it would go to the other overload.

[cjdb]

libcxx/include/__iterator/common_iterator.h

169

But this is not i == i, it's x == y. What you're saying makes sense for input iterators, but what about forward iterators, or even contiguous iterators?

This is the overload that's chosen when we evaluate i == i, so Tim's got a point. I'm also not sure what the assertion would achieve? Are you trying to prevent i == i?

[cjdb]

Thanks for working on such an ugly type. In addition to my inline comments, please add

• a module map entry
• iterator conformance tests

libcxx/include/__iterator/common_iterator.h

35

Can we define __proxy and __postfix_proxy out-of-line please?

63

This should be private. Also, hold is not a particularly descriptive name to me.

107

How about "Dereferencing a common_iterator is only possible if it is holding an iterator, but this one is holding a sentinel."?

122–124

Can we get this into a named object please? Perhaps __common_iterator_has_arrow?

153–155

Please name this.

272–274

Seconded. Please use _If, if you can.

libcxx/test/std/iterators/predef.iterators/iterators.common/plus_plus.pass.cpp

86 ↗

(On Diff #358790)

Please prefix "postfix" to this sentence.

libcxx/test/support/test_iterators.h

164 ↗

(On Diff #356841)

I think this functionality should instead be reflected in cpp20_input_iterator (and in a separate patch, if it breaks any code).

[zoecarver]

libcxx/include/__iterator/common_iterator.h

169

I'm talking about two completely unrelated iterators, for example, this:

auto iter1 = random_access_iterator<int*>(buffer + 1);
auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);

auto iter2 = forward_iterator<int*>(buffer + 4);
auto commonIter2 = std::common_iterator<decltype(iter2), sentinel_type<int*>>(iter2);

assert(commonIter1 == commonIter2);

(An actual test case ^)

If above is UB, it's not clear to me where that is stated. Even so, if it is UB for some reason, I think it would be great to add an assertion. And if it's well defined, well that seems terrible (and my preference would be to create an LWG issue and still add an assertion or something, because that's definitely a but, but maybe others disagree).

[tcanens]

libcxx/include/__iterator/common_iterator.h

169

So pathological mix-up scenarios where you compare completely unrelated things? It's hard to think of a non-contrived example where that matters.

I don't really care about this case either way; I'm just not convinced that it's worth the trouble (coming up with something that doesn't damage valid uses can be tricky).

@CaseyCarter thoughts?

[CaseyCarter]

libcxx/include/__iterator/common_iterator.h

169

It's hard to care about this. The domain of equality for forward_iterators is iterators obtained from the same range, so generic code can't perform this comparison. To do so in concrete code - when you know the result is useless - would be silly. In other words: if you think this is weird, then don't do it.

Conversely, if you want comparison of common_iterator<I1, S> and common_iterator<I2, S> to be sensible you can always make I1 and I2 model equality_comparable.

[zoecarver]

Apply Chris' review comments.

[zoecarver]

libcxx/include/__iterator/common_iterator.h

35

Why?

63

Because of the friend issues we discussed with transform_view on #libcxx we unfortunately can't have this be private.

122

@tcanens Another potential LWG issue: shouldn't this be is_pointer_v<_Iter> || requires(const _Iter& __i) { __i.operator->(); }? If not, do we need to have the is_pointer condition below? Can it ever be hit?

122–124

I don't want to add another "has arrow" concept that means something different from __has_arrow. Depending on my comment above, we might be able to use that here, though.

169

I guess it's pathological, but it would also be pathological to even compare any iterators (read: not sentinels) that use this overload. Basically, you're saying "you should only compare iterators here that are equal." In which case, why does this overload even need to work with iterators (read: not sentinels)?

We have two cases: 1) someone is using this correctly. They have two iterators that are equal. This returns true.

2. Someone is using this incorrectly. They have two iterators that are not equal.

You're saying the second case isn't worth worrying about because it would be pathological. This implies that no one should ever call this function without knowing if their iterators are equal beforehand. This begs the question: why do they even need to call this function in the first place? If they know their iterators are equal, it's pointless to compare them.

I think we should add a precondition or something that says i or j is 1. And I'd like to add that as an assertion here.

173

I'm not opposed to using indexes, but a concrete example would be nice, to show that there's actually a problem. I find using types much more readable, so I'd want a solid reason not to do it.

libcxx/test/support/test_iterators.h

164 ↗

(On Diff #356841)

Common iterator requires that we're copyable, so we really need this type. But I'm fully supportive of making cpp20_input_iterator non-default-constructible in a separate patch.

[tcanens]

libcxx/include/__iterator/common_iterator.h

122

is_reference_v<iter_reference_t<_I2>> should be enough to catch pointers.

169

Basically, you're saying "you should only compare iterators here that are equal." In which case, why does this overload even need to work with iterators (read: not sentinels)?

Because perfectly valid generic code written to C++17 iterator requirements may want to do this, perhaps because it makes the code simpler. Breaking valid code makes common_iterator unfit for its only purpose.

This is like "why does array<T, 0> has a front() when it's always UB to call it"? Well, because generic code may want to do so from a dynamically unreachable context.

I think we should add a precondition or something that says i or j is 1. And I'd like to add that as an assertion here.

That's a non-starter as far as I'm concerned.

[cjdb]

libcxx/include/__iterator/common_iterator.h

35

I find class-in-class definitions to clutter the outer-class definition. For the record, it's still common_iterator<_Iter, _Sent>::__proxy.

169

Basically, you're saying "you should only compare iterators here that are equal." In which case, why does this overload even need to work with iterators (read: not sentinels)?

Because perfectly valid generic code written to C++17 iterator requirements may want to do this, perhaps because it makes the code simpler. Breaking valid code makes common_iterator unfit for its only purpose.

This is like "why does array<T, 0> has a front() when it's always UB to call it"? Well, because generic code may want to do so from a dynamically unreachable context.

That it's UB means an implementation can assert that N != 0.

I think we should add a precondition or something that says i or j is 1. And I'd like to add that as an assertion here.

That's a non-starter as far as I'm concerned.

Could you please elaborate on why you think this is a non-starter? Having said that, I keep bouncing on my opinion for this matter whenever new evidence is put forward.

[ldionne]

libcxx/include/__iterator/common_iterator.h

169

@CaseyCarter said:

It's hard to care about this. The domain of equality for forward_iterators is iterators obtained from the same range, so generic code can't perform this comparison.

Ok. So basically, we never expect this overload to be called with It1 and It2 being forward_iterators, and this should only be called for input_iterators? In that case, I don't understand what's preventing us from adding a constraint !forward_iterator<It1> && !forward_iterator<It2> -- it's really cheap to do that, and we'd catch this pathological case at compile-time instead of having really strange behavior at runtime. And this will still work for all input_iterators, which is the only intended use case for this comparison operator if I followed correctly. Do you agree?

@zoecarver Whatever we end up doing here, I agree with Arthur's suggestion to add an assertion like static_assert(!equality_comparable_with<_Iter, _I2>); before returning true.

[tcanens]

libcxx/include/__iterator/common_iterator.h

169

Basically, you're saying "you should only compare iterators here that are equal." In which case, why does this overload even need to work with iterators (read: not sentinels)?

Because perfectly valid generic code written to C++17 iterator requirements may want to do this, perhaps because it makes the code simpler. Breaking valid code makes common_iterator unfit for its only purpose.

This is like "why does array<T, 0> has a front() when it's always UB to call it"? Well, because generic code may want to do so from a dynamically unreachable context.

That it's UB means an implementation can assert that N != 0.

At runtime, not at compile time. "It's always UB when called" doesn't justify = delete; or removal or static_assert in the body, because reasonable code can do if (not a.empty()) { do_something(a.front()); }.

Similarly here, just because the only meaningful comparison for iterators must return true doesn't justify making the comparison undefined.

I think we should add a precondition or something that says i or j is 1. And I'd like to add that as an assertion here.

That's a non-starter as far as I'm concerned.

Could you please elaborate on why you think this is a non-starter? Having said that, I keep bouncing on my opinion for this matter whenever new evidence is put forward.

Comparing a non-singular common_iterator with itself, or a copy of itself, must be valid. Making perfectly valid uses undefined at runtime just to catch pathological cases that are unlikely to ever arise in practice is totally backwards.

I'm open to something like what Louis suggested.

[zoecarver]

At runtime, not at compile time.
[...]
I'm open to something like what Louis suggested.

To clarify, I'm suggesting that we add a runtime assertion that does some combination of i == 1 || j == 1 || (!forward_iterator<It1> && !forward_iterator<It2>).

[ldionne]

I'm not seeing any blocking issues anymore, and it looks reasonable to me. I think we should file the LWG issue for operator== and ship it. Other reviewers, please chime in if you have feedback you really want to see addressed before this is shipped, otherwise @zoecarver feel free to ship this after the weekend or so (to give time for people to see this).

(needs CI)

libcxx/include/__iterator/common_iterator.h

169

@zoecarver Let's implement it per the spec for now and file a LWG issue with a proposed resolution like this:

template<class _I2, sentinel_for<_Iter> _S2>
    requires sentinel_for<_Sent, _I2> && 
             !equality_comparable_with<_Iter, _I2> && // I think this is required to avoid an ambiguity with the other overload
             !forward_iterator<_Iter> &&
             !forward_iterator<_I2>
friend bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y);

Either this is accepted by LWG and we fix it before we've had time to ship it anyways, or it's not and in that case we'll be conforming (and hopefully LWG explains why they think this isn't a good resolution). Are you willing to file it?

[zoecarver]

Rebase.

[zoecarver]

Rebase (again).

[zoecarver]

Fix modules issues (hopefully).

[cjdb]

libcxx/include/variant

209 ↗

(On Diff #359949)

Please sort the list of includes.

libcxx/include/__iterator/common_iterator.h

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
+// REVIEW-NOTE: This is *not* part of the transform_view patch and will be added by a *separate* PR.
 template<class _I1, class _I2>
 concept indirectly_swappable =
     indirectly_readable<_I1> &&
     indirectly_readable<_I2> &&
     requires(const _I1 i1, const _I2 i2) {
         ranges::iter_swap(i1, i1);
         ranges::iter_swap(i1, i2);
         ranges::iter_swap(i2, i1);
         ranges::iter_swap(i2, i2);
     };
+// END-REVIEW-NOTE.
+
+struct default_sentinel_t {};
 
 template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
   requires (!same_as<_Iter, _Sent> && copyable<_Iter>)
 class common_iterator {
-  union {
-    _Iter __iter;
-    _Sent __sent;
+  union _Hold {
+    _Iter __iter; // __index == 0;
+    _Sent __sent; // __index == 1;
+
+    _Hold() = default;
+    constexpr _Hold(_Iter __iter) : __iter(_VSTD::move(__iter)) {}
+    constexpr _Hold(_Sent __sent) : __sent(_VSTD::move(__sent)) {}
+  } __u;
+  bool __index;
+
+  class __proxy {
+    friend common_iterator;
+
+    iter_value_t<_Iter> __value;
+    constexpr __proxy(iter_reference_t<_Iter>&& __x)
+      : __value(__x) {}
+
+  public:
+    constexpr const iter_value_t<_Iter>* operator->() const {
+      return _VSTD::addressof(__value);
+    }
+  };
+
+  class __postfix_proxy {
+    friend common_iterator;
+
+    iter_value_t<_Iter> __value;
+    constexpr __postfix_proxy(iter_reference_t<_Iter>&& __x)
+      : __value(__x) {}
+
+  public:
+    constexpr const iter_value_t<_Iter>& operator*() const {
+      return __value;
+    }
   };
 
 public:
   common_iterator() = default;
 
-  constexpr common_iterator(_Iter __i);
-  constexpr common_iterator(_Sent __s);
+  constexpr common_iterator(_Iter __i) : __u(_VSTD::move(__i)), __index(false) {}
+  constexpr common_iterator(_Sent __s) : __u(_VSTD::move(__s)), __index(true ) {}
 
   template<class _I2, class _S2>
     requires convertible_to<const _I2, _Iter> && convertible_to<const _S2&, _Sent>
-  common_iterator(const common_iterator<_I2, _S2>& __other);
+  constexpr common_iterator(const common_iterator<_I2, _S2>& __other)
+    : __u(__other.__u), __index(__other.__index) {}
 
   template<class _I2, class _S2>
     requires convertible_to<const _I2, _Iter> && convertible_to<const _S2&, _Sent> &&
              assignable_from<const _I2, _Iter> && assignable_from<const _S2&, _Sent>
-  common_iterator& operator=(const common_iterator<_I2, _S2>& __other);
+  constexpr common_iterator& operator=(const common_iterator<_I2, _S2>& __other) {
+    __u = __other.__u;
+    __index = __other.__index;
+  }
+
+  constexpr decltype(auto) operator*() { return *__u.__iter; }
+  constexpr decltype(auto) operator*() const
+    requires __dereferenceable<const _Iter>
+  { return *__u.__iter; }
 
-  decltype(auto) operator*();
-  decltype(auto) operator*() const
-    requires __dereferenceable<const _Iter>;
-  decltype(auto) operator->() const
+  constexpr decltype(auto) operator->() const
     requires indirectly_readable<const _Iter> &&
     (requires(const _Iter& __i) { __i.operator->(); } ||
      is_reference_v<iter_reference_t<_Iter>> ||
-     constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>);
-
-  common_iterator& operator++();
-  decltype(auto) operator++(int);
+     constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>) {
+    if constexpr (is_pointer_v<_Iter> || requires(const _Iter& __i) { __i.operator->(); })    {
+      return __u.__iter;
+    } else if constexpr (is_reference_v<iter_reference_t<_Iter>>) {
+      auto&& __tmp = *__u.__iter;
+      return _VSTD::addressof(__tmp);
+    } else {
+      return __proxy(*__u.__iter);
+    }
+  }
+
+  constexpr common_iterator& operator++() { ++__u.__iter; return *this; }
+  constexpr decltype(auto) operator++(int) {
+    if constexpr (forward_iterator<_Iter>) {
+      auto __tmp = *this;
+      ++*this;
+      return __tmp;
+    } else if constexpr (requires (_Iter& __i) { { *__i++ } -> __referenceable; } ||
+                         !constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>) {
+      return __u.__iter++;
+    } else {
+      __postfix_proxy __p(*this);
+      ++*this;
+      return __p;
+    }
+  }
 
   template<class _I2, sentinel_for<_Iter> _S2>
     requires sentinel_for<_Sent, _I2>
-  friend bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y);
+  friend constexpr bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    if (__x.__index == __y.__index)
+      return true;
+
+    if (__x.__index == 0)
+      return __x.__u.__iter == __y.__u.__sent;
+
+    return __x.__u.__sent == __y.__u.__iter;
+  }
 
   template<class _I2, sentinel_for<_Iter> _S2>
     requires sentinel_for<_Sent, _I2> && equality_comparable_with<_Iter, _I2>
-  friend bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y);
+  friend constexpr bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    if (__x.__index && __y.__index)
+      return true;
+
+    if (__x.__index == 0 && __y.__index == 0)
+      return __x.__u.__iter == __y.__u.__iter;
+
+    if (__x.__index == 0)
+      return __x.__u.__iter == __y.__u.__sent;
+
+    return __x.__u.__sent == __y.__u.__iter;
+  }
 
   template<sized_sentinel_for<_Iter> _I2, sized_sentinel_for<_Iter> _S2>
     requires sized_sentinel_for<_Sent, _I2>
-  friend iter_difference_t<_I2> operator-(const common_iterator& __x, const common_iterator<_I2, _S2>& __y);
+  friend constexpr iter_difference_t<_I2> operator-(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    if (__x.__index && __y.__index)
+      return 0;
+
+    if (__x.__index == 0 && __y.__index == 0)
+      return __x.__u.__iter - __y.__u.__iter;
 
-  friend iter_rvalue_reference_t<_Iter> iter_move(const common_iterator& __i)
+    if (__x.__index == 0)
+      return __x.__u.__iter - __y.__u.__sent;
+
+    return __x.__u.__sent - __y.__u.__iter;
+  }
+
+  friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const common_iterator& __i)
     noexcept(noexcept(ranges::iter_move(declval<const _Iter&>())))
-      requires input_iterator<_Iter>;
+      requires input_iterator<_Iter>
+  { return ranges::iter_move(__i.__u.__iter); }
 
   template<indirectly_swappable<_Iter> _I2, class _S2>
-    friend void iter_swap(const common_iterator& __x, const common_iterator<_I2, _S2>& __y)
-      noexcept(noexcept(ranges::iter_swap(declval<const _Iter&>(), declval<const _I2&>())));
+  friend constexpr void iter_swap(const common_iterator& __x, const common_iterator<_I2, _S2>& __y)
+      noexcept(noexcept(ranges::iter_swap(declval<const _Iter&>(), declval<const _I2&>())))
+  { return ranges::iter_swap(__x.__u.__iter, __y.__u.__iter); }
+};
+
+template<class _Iter, class _Sent>
+struct incrementable_traits<common_iterator<_Iter, _Sent>> {
+  using difference_type = iter_difference_t<_Iter>;
+};
+
+template<class _Iter>
+concept __denotes_forward_iter =
+  requires {
+    typename iterator_traits<_Iter>::iterator_category;
+  } &&
+  derived_from<typename iterator_traits<_Iter>::iterator_category, forward_iterator_tag>;
+
+template<class _Iter, class _Sent>
+concept __common_iter_has_ptr_op = requires(const common_iterator<_Iter, _Sent> __a) {
+  __a.operator->();
 };
 
+template<class _Iter, class _Sent>
+struct iterator_traits<common_iterator<_Iter, _Sent>> {
+  using iterator_concept = conditional_t<forward_iterator<_Iter>,
+                                         forward_iterator_tag,
+                                         input_iterator_tag>;
+  using iterator_category = conditional_t<__denotes_forward_iter<_Iter>,
+                                          forward_iterator_tag,
+                                          input_iterator_tag>;
+  using pointer = conditional_t<__common_iter_has_ptr_op<_Iter, _Sent>,
+                                decltype(declval<const common_iterator<_Iter, _Sent>>().operator->()),
+                                void>;
+  using value_type = iter_value_t<_Iter>;
+  using difference_type = iter_difference_t<_Iter>;
+  using reference = iter_reference_t<_Iter>;
+};
+
+
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_COMMON_ITERATOR_H

libcxx/test/std/iterators/predef.iterators/iterators.common/common_iterator.pass.cpp

 // template<input_or_output_iterator I, sentinel_for<I> S>
 //  requires (!same_as<I, S> && copyable<I>)
 // class common_iterator;
 
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_iterators.h"
+
+template <class It>
+class simple_iterator
+{
+    It it_;
+
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    constexpr It base() const {return it_;}
+
+    simple_iterator() = default;
+    explicit constexpr simple_iterator(It it) : it_(it) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr simple_iterator& operator++() {++it_; return *this;}
+    constexpr simple_iterator operator++(int)
+        {simple_iterator tmp(*this); ++(*this); return tmp;}
+};
+
+template <class It>
+class value_iterator
+{
+    It it_;
+
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    constexpr It base() const {return it_;}
+
+    value_iterator() = default;
+    explicit constexpr value_iterator(It it) : it_(it) {}
+
+    constexpr value_type operator*() const {return *it_;}
+
+    constexpr value_iterator& operator++() {++it_; return *this;}
+    constexpr value_iterator operator++(int)
+        {value_iterator tmp(*this); ++(*this); return tmp;}
+};
+
+
+template<class T>
+struct sentienl_type {
+  T base;
+
+  template<class U>
+  friend constexpr bool operator==(const sentienl_type& lhs, const U& rhs) { return lhs.base == rhs.base(); }
+  template<class U>
+  friend constexpr bool operator==(const U& lhs, const sentienl_type& rhs) { return lhs.base() == rhs.base; }
+};
+
+template<class T>
+struct sized_sentienl_type {
+  T base;
+
+  template<class U>
+  friend constexpr bool operator==(const sized_sentienl_type& lhs, const U& rhs) { return lhs.base - rhs.base(); }
+  template<class U>
+  friend constexpr bool operator==(const U& lhs, const sized_sentienl_type& rhs) { return lhs.base() - rhs.base; }
+  template<class U>
+  friend constexpr auto operator- (const sized_sentienl_type& lhs, const U& rhs) { return lhs.base - rhs.base(); }
+  template<class U>
+  friend constexpr auto operator- (const U& lhs, const sized_sentienl_type& rhs) { return lhs.base() - rhs.base; }
+};
+
+template<class I, class S>
+concept ValidCommonIterator = requires {
+  typename std::common_iterator<I, S>;
+};
+
+constexpr void testIteratorTraits() {
+  {
+    using Iter = simple_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, int*>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = value_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    // Note: IterTraits::pointer == __proxy.
+    static_assert(!std::same_as<IterTraits::pointer, int*>);
+    static_assert(std::same_as<IterTraits::reference, int>);
+  }
+  {
+    using Iter = cpp17_input_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, Iter>); // TODO: is this right?
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = forward_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, Iter>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = random_access_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, Iter>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+}
+
+constexpr void testCtor() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  static_assert(std::is_default_constructible_v<std::common_iterator<int*, sentienl_type<int*>>>);
+
+  // Not copyable:
+  static_assert(!ValidCommonIterator<cpp20_input_iterator<int*>, sentienl_type<int*>>);
+  // Same iter and sent:
+  static_assert(!ValidCommonIterator<cpp17_input_iterator<int*>, cpp17_input_iterator<int*>>);
+
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+  }
+}
+
+constexpr void testMembers() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    auto iter1 = simple_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = simple_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = value_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = value_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(*commonIter1.operator->().operator->() == 1);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(*commonIter2.operator->().operator->() == 1);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = cpp17_input_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->().base() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->().base() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = forward_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->().base() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->().base() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = random_access_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->().base() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->().base() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sized_sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sized_sentienl_type<int*>>(sized_sentienl_type<int*>{buffer + 8});
+    assert(commonIter1 - commonSent1 == -8);
+    assert(commonSent1 - commonIter1 == 8);
+    assert(commonIter1 - commonIter1 == 0);
+    assert(commonSent1 - commonSent1 == 0);
+  }
+}
+
+constexpr void testCust() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+}
 
 constexpr bool test() {
+  testIteratorTraits();
+  testCtor();
+  testMembers();
+  testCust();
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }