[libcxx][ranges] add views::join adaptor object. added test coverage to join_view

[huixie90]

Summary

• added views::join adaptor object
• added test for the adaptor object
• fixed some join_view's tests. e.g iter_swap test
• added some negative tests for join_view to test that operations do not exist when constraints aren't met
• added tests that locks down issues that were already addressed in previous change
  • LWG3500 join_view::iterator::operator->() is bogus
  • LWG3313 join_view::iterator::operator-- is incorrectly constrained
  • LWG3517 join_view::iterator's iter_swap is underconstrained
  • P2328R1 join_view should join all views of ranges
• fixed some issues in join_view and added tests
  • LWG3535 join_view::iterator::iterator_category and ::iterator_concept lie
  • LWG3474 Nesting `join_views` is broken because of CTAD
• added tests for an LWG issue that isn't resolved in the standard yet, but the previous code has workaround.
  • LWG3569 Inner iterator not default_initializable

[huixie90]

fix CI failure

[huixie90]

work around apple CI failure (caused by clang12 bug)

[ldionne]

Could you please update the status document to show which LWG issues you added tests for? And also it would be nice to list them in the commit message!

[huixie90]

update issue status

[huixie90]

In D123466#3442596, @ldionne wrote:

Could you please update the status document to show which LWG issues you added tests for? And also it would be nice to list them in the commit message!

@ldionne sure. I have updated the review summary, the status doc. Btw, by searching join_view in those docs, I actually found another issue (about iterator_category and iterator_concept) which wasn't fixed previously so I updated the join_view to fix that issue.

[var-const]

Thanks a lot for working on this! The fixes and additional testing look great.

libcxx/include/__ranges/join_view.h

342

Formatting nit: namespaces don't introduce a new indentation level in the LLVM style (see https://llvm.org/docs/CodingStandards.html#namespace-indentation).

(this doesn't apply to namespace __cpo below because it was previously decided to special-case those namespaces)

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

38

Nit: I think concepts are usually indented 2 (sometimes 4) spaces in our code base, I'd move this line way left.

51

Nit: I'd suggest always using decltype(auto) with same_as -- plain auto can decay and hide that a reference is returned. Now, it's very unlikely to happen here, but I feel consistently using decltype(auto) is conceptually simpler (no need to judge each case), always correct and not that much more to type.

67

Ultranit: extra backticks.

70

Question: why not use same_as like above?

86

Question: why are the double parentheses necessary? (here and below)

86

Does this check provide any additional coverage? It seems like it does the same as inners | views::join, except it doesn't exercise the runtime part.

libcxx/test/std/ranges/range.adaptors/range.join.view/begin.pass.cpp

33

Can you add static_asserts to verify the important properties of this class?

109

Nit: can you please move the comment to come just before the scope, for consistency with the rest of the file? (and also add an empty line in-between the new test cases)

115

Optional: consider static asserting !is_reference_v<range_reference_t<std::as_const<decltype(innerRValueRange)>>>.

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

31

Please add a brief comment explaining the purpose of the test.

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

61

Is it possible to check a) whether an iterator or a sentinel is returned; b) whether the returned iterator/sentinel is const?

63–66

Because you already call std::as_const(jv).end() above, this check seems redundant (applies throughout -- only the negative checks are necessary).

65

Question: what is the purpose of this check?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/arrow.pass.cpp

29

Optional: this seems a little overkill for a test-local class.

57

This check seems redundant -- the call to jv.begin()->x above already seems to check that the iterator has operator->.

73

Can you add a little more context to the comment (here and below) to explain what exactly is being checked?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.other.pass.cpp

48–59

This check seems redundant -- the code above already constructed a const_iterator from a non-const iterator.

51

General nit: it would be easier to see where one test case ends and another one starts if they were additionally separated by empty lines.

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.parent.outer.pass.cpp

19

Nit: it's not obvious (to me, at least) from the name that "default" refers to the default constructor. How about something like NoDefaultCtrIter or NotDefaultCtrableIter?

37

Nit: can you expand a little to let the reader know what the test is checking without opening the issue?

38

Optional nit: deduce the size?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.move.pass.cpp

45

Question: why is checking iter_move with another iterator necessary?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.swap.pass.cpp

28

Can you please expand the comment to provide a little more context -- does this test check that the LWG issue is fixed?

libcxx/test/std/ranges/range.adaptors/range.join.view/sentinel/ctor.other.pass.cpp

34

Can you add a short comment explaining what this test does?

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

143

From the name, I would expect a buffer to own the memory, whereas this is non-owning view. Can you use std::span?

156

Nit: wrong indentation (1 space instead of 2 spaces IIRC).

158

Nit: move the brace to the previous line? (applies below as well)

159

Nit: I don't think it's necessary to explicitly mention this, and we don't normally do it. This should be just NonConstIter(buffer_).

169

Optional: I think this line can be used unconditionally (it will be NonConstIter(NonConstIter(...)) if the types are the same, but given that this is test code, I don't think the potential extra object matters).

183

Can you add a brief comment explaining the purpose of this class?

231

Nit: looks like there's an extra blank line (2 blank lines in a row).

286

What is the purpose of this class?

287

Formatting nit: move the brace to the previous line.

293

s/referece/reference/. Is this alias necessary? Also, can you add a comment to explain why it's not actually a reference type?

307

Would == default work?

322

Nit: add a space after the comma.

350

Question: IIRC, cpp20_input_iterator is move-only, so just from reading the name, this class seems unnecessary. However, it also has operator->, which I presume is important for how the class is used. Consider renaming and adding a brief comment explaining why this class is necessary.

372

Also assert that this class is an input_iterator?

375

Question: why can't sentinel_wrapper be used here?

378

Nit: extra space.

379

Question: can this be = default?

394

Nit: add a space before the opening brace.

397

Add brief comments to explain why these reference aliases are just value types?

402

Given that this class is default-constructible, should these be initialized to nullptr?

[var-const]

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/decrement.pass.cpp

77

Why is this necessary?

94

Can you check the iterator type?

98

Nit: can this avoid mixing same_as and static_assert and just use one of them consistently?

106

These 4 tests are very similar -- consider creating a constexpr function that takes the initializer of join_view as a parameter and asserts that the iterator cannot be decremented.

131

Similar nit to other places -- can you please expand the comment a little bit to make it clear whether this tests for the fixed behavior?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/member_types.compile.pass.cpp

59–63

What is the reason for this change?

63

Seems redundant with the check a couple lines above.

83

Same nit as other similar comments (please add more context).

91

Question: why is this type used here?

102

Question: can this check be more specific?

[huixie90]

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

86

decltype(inner) is Inner[3], but decltype((inner)) is Inner (&) [3], which is an lvalue reference. In expression inners | views::join, inners is lvalue reference

86

This doesn't add additional coverage. However, this was suggested by @philnik, to check that the local helper concept CanBePiped is able to return true. (as supposed concept CanBePiped = false that renders the negative test useless

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

61

unfortunately iterator and sentinel are private exposition only classes. It is not directly accessible. Therefore these tests are testing the type of them indirectly.

For example, to test end returns an iterator, we can check
std::ranges::common_range<decltype(jv)> is true, because common_range means begin and end returns the same type.

if the above is false, it means we have an sentinel, to test end() returns sentinel<false> as oppose to sentinel<true>, we can check !std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>

63–66

again, this was suggested by philnik to make sure our local HasConstEnd isn't always returning false

65

see the above explanation about how to check it returns iterator<true>, iterator<false, sentinel<true>, sentinel<false

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/arrow.pass.cpp

57

again, happy to remove. was just to double check if HasArrow is doing what it is suppose to doing

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/decrement.pass.cpp

77

for some reason, gcc fails the compile time test (fine at runtime). I think it is a gcc bug ( i need to find a minimum reproducible example)

94

the iterator is a private class and it is not straightforward to test the actual type. any suggestions?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.move.pass.cpp

45

If join_view::iterator completely forgot to implement iter_move, the default implementation of std::ranges::iter_move would actually call std::move(*it). The original test point would pass anyway (std::move(int&) == int&&)

Here I am adding this additional test with a custom underlying iterator where iter_move isn't simply std::move(*it), and also it has got an int to track if its own iter_move customisation is called

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/member_types.compile.pass.cpp

59–63

On another review, @philnik was skeptical about the macro ASSERT_SAME_TYPE. Here is his comment

I'm not a huge fan of ASSERT_SAME_TYPE in general. It seems to me like a macro that is there for a very small amount of convenience and makes the code much harder to read IMO. At least I haven't seen a case where it makes life a lot easier.

I was following his suggestion to not to use it. happy to revert. I am ok with either way. what is your opinion?

63

again, it is philnik's suggestion to double check the HasIterCategory is not always returning false

91

This test point it to check the value_type is defined correctly. This particular type's value_type isn't simply remove_cvref<reference>. I can add additional static_assert here

102

could you please elaborate? This test point is checking difference_type is defined correctly, which should be the common_type of the inner and outer difference_type

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

143

I will rename it. I'd like to have access to the underlying pointer and I don't think std::span has that property

158

sure I will try my best. In general, I use clang-format to format document. It is almost impossible to format the new code to be the same style as the existing code base.

159

this is required because the base class is a template

169

I still prefer to separate them. It is clear that in one case, we want to have a common_range and in another case, we want a !common_range

286

It is an iterator where its reference is a prvalue. It is used in some of the tests where the inner range produces prvalue reference

350

yes. will rename it, it is used in the arrow test.

375

IIRC, sentinel requires semiregular. However, sentinel_wrapper simply delegates to the iterator, which will have a deleted copy constructor in this case, which does not model semiregular

379

I think it is not possible? They are two different types (sentinel and iterator)

[huixie90]

addressed review comments

[huixie90]

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

38

lol. I adopted your suggestion but arc linter put the indentation back. what is the command to disable arc linter?

[philnik]

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

38

--nolint

[ldionne]

This generally looks really good -- I don't have much to add TBH. Thanks a lot for increasing the coverage and being diligent in your testing, this is really valuable.

One thing I would suggest (for the future) would be to split large reviews into a few orthogonal patches. Each LWG issue could have been addressed on its own, same for the added testing and the join adaptor. That being said, don't split it off now since this has gotten reviewed. But in the future, splitting it into orthogonal patches when possible will generally make it easier for reviewers to give you good feedback quickly.

I don't have any blocking comments, so I'm happy when the other reviewers are. Thanks a lot for the contribution, this is great!

libcxx/docs/Status/Cxx2bIssues.csv

47 ↗

(On Diff #422440)

59 ↗

(On Diff #422440)

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

13–14

38

Specifically, you can upload your patch with arc diff --nolint. That should really be the default given how noisy it is :-)

75

Those can be simplified as ASSERT_SAME_TYPE(std::ranges::range_reference_t<decltype(jv2)>, Foo&);. Non-blocking.

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

28

We haven't been doing this very often, but I think it's a really neat and concise way of making sure we're exhaustive. I think we should start doing this more often when it makes sense.

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

77–80

It should be sufficient to use sentinel_wrapper in order to remove those (and below).

356

If some of those are only used in a single test file, I would consider moving them to that test file in order to keep this one smaller, and keep things as localized as possible. I think this is the case here, and IMO the test in arrow.pass.cpp would be a bit easier to understand if we defined this type in arrow.pass.cpp, closer to where it is used. For other types that are reused across multiple tests, I think it's worth avoiding code duplication of course. Non-blocking.

[huixie90]

address review comments

[var-const]

Thanks for addressing the feedback (and sorry about the slow review)! Almost LGTM with just a few nits/questions.

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

70

Seems not done, unless I'm missing something.

86

Thanks for explaining, makes sense.

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

27

Shouldn't it be value initialise? Default initialization would leave i uninitialized.

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

61

Optional: maybe create helper type traits or concepts to make this more obvious? E.g. is_sentinel, is_const_iterator, etc. Feel free to ignore.

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/arrow.pass.cpp

74

Ultranit: I think should not be defined would be a little clearer, but it's a really small thing, so feel free to ignore (below as well).

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.parent.outer.pass.cpp

40

Nit: s/anner/inner/?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/decrement.pass.cpp

77

Please add a comment explaining the issue (if you already have filed a GCC bug or of it's easy to do, add a link to the comment, but I wouldn't block this patch on filing the GCC bug). In general, when doing this sort of compiler- or platform-specific workarounds, it's always helpful to leave a comment explaining the issue.

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.move.pass.cpp

45

Sorry, what I meant is, why are both iter_move_called_times1 and iter_move_called_times2 necessary? What case does iter_move_called_times2 cover that isn't covered by iter_move_called_times1?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/member_types.compile.pass.cpp

59–63

Thanks for explaining. Re. ASSERT_SAME_TYPE -- personally, I actually find it a little easier to read with less boilerplate, but it's definitely not worth it to go and change it back now. I don't think there ever was a general agreement to stop using ASSERT_SAME_TYPE, so I think it comes down to personal preference (@philnik, please correct me if I'm wrong on this).

102

Never mind, on a second thought I think the current state is reasonable (I was going to suggest using a more specific type but it would be non-portable, and trying to work around that is not worth the trouble).

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

143

I don't think std::span has that property

Wouldn't data() work?

286

Thanks for explaining. Optionally, consider renaming it to copying_iterator.

349

Nit: I found this part (about zip_view) a little confusing, can you elaborate? If you mean that zip_view will have a similar move_swap_aware_iter type, then it's better to just omit it -- currently, the test code for different classes is written to be self-contained.

[huixie90]

address comments

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

70

Could you please be more explicitly about which line is missing? I think I changed all the things to

std::same_as<expected_type> decltype(auto) x = ...;

Line 72 and 75 are not checking the type of the variable but the range_reference_t of the type of the variable.

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

61

thanks for the suggestion, I did consider to come up with better helper concepts but it is not trivial to come up with one. The concept cannot simple take just one iterator type like

template <class T>
concept is_sentinel = ...

because there is no easy way to test if a type is the sentinel type. it will probably end of with something like

template <class T, class Iterator>
concept is_sentinel = !same_as<T, Iterator>

which checks if T is the same type as the iterator. but then this concept seems to be a bit less useful, as it is basically the common_range

template <class R>
concept common_range = same_as<range_iterator_t<R>, range_sentinel_t<R>>

any suggestions?

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.move.pass.cpp

45

since I am joining a range of 2 inner ranges, this is just to make sure that the iter_move is called on the iterator of the correct inner range after each step. If you think this is unnecessary I can delete it and just testing joining a range of 1 inner range

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

143

that Span/Buffer class is deleted now. Now I only have the BufferView template where its template parameters are iterators and sentinels.

349

this is to test joining a range of zip_view without actually having zip_view. This iterator is emulating proxy-like iterator where value_type and reference do not simply have the remove_cvref relation. zip_view's iterator is just one of this kind. The test is not testing zip_view but joining a range of zip-like ranges

[var-const]

LGTM (with just a couple of really small comments). Thanks!

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

70

Ah, I missed that the type is adjusted in this case, thanks for pointing it out.

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

61

this concept seems to be a bit less useful, as it is basically the common_range

I think the main utility of this concept would be its descriptive name, so even as an alias for common_range it could have some value (it's local to this file so it's fine for this concept to be not very useful in general). But I don't want to block this patch on this -- feel free to keep things as they are.

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.move.pass.cpp

45

It makes sense -- maybe add a short comment to that effect, though.

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

349

How about the following rephrasing?

// This is a proxy-like iterator where `reference` is a value type, and `reference` and `value_type`
// are distinct types (similar to `zip_view::iterator`).

Though given that, like you say, there are other iterators with similar properties, perhaps the part about it being similar to zip_view is unnecessary -- I think I'd drop it and and just keep the explanation about it being a proxy iterator.

[huixie90]

address some comments

[huixie90]

I don't have access to push the commits.
Name: Hui Xie
Email: [e-mail]

libcxx/include/__ranges/join_view.h

 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/non_propagating_cache.h>
-#include <__ranges/ref_view.h>
-#include <__ranges/subrange.h>
+#include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
-#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <optional>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
friend constexpr void iter_swap(const __iterator& __x, const __iterator& __y)
       requires indirectly_swappable<_Inner>
     {
       return ranges::iter_swap(*__x.__inner_, *__y.__inner_);
     }
   };
 
   template<class _Range>
   explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
   
+namespace views {
+namespace __join_view {
+  struct __fn : __range_adaptor_closure<__fn> {
+    template<class _Range>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))))
+      -> decltype(      join_view<all_t<_Range&&>>(std::forward<_Range>(__range)))
+      { return          join_view<all_t<_Range&&>>(std::forward<_Range>(__range)); }
+  };
+} // namespace __join_view
+inline namespace __cpo {
+  inline constexpr auto join = __join_view::__fn{};
+} // namespace __cpo
+} // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_JOIN_VIEW_H

libcxx/test/std/ranges/range.adaptors/range.join.view/adaptor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::join
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+
+#include "types.h"
+
+struct MoveOnlyOuter : SimpleForwardCommonOuter<ForwardCommonInner> {
+  using SimpleForwardCommonOuter<ForwardCommonInner>::SimpleForwardCommonOuter;
+
+  constexpr MoveOnlyOuter(MoveOnlyOuter&&) = default;
+  constexpr MoveOnlyOuter(const MoveOnlyOuter&) = delete;
+
+  constexpr MoveOnlyOuter& operator=(MoveOnlyOuter&&) = default;
+  constexpr MoveOnlyOuter& operator=(const MoveOnlyOuter&) = delete;
+};
+
+struct Foo {
+  int i;
+  constexpr Foo(int ii) : i(ii) {}
+};
+
+template <class View, class T>
+concept CanBePiped = requires(View&& view, T&& t) {
+                       { std::forward<View>(view) | std::forward<T>(t) };
+                     };
+
+constexpr bool test() {
+  int buffer1[3] = {1, 2, 3};
+  int buffer2[2] = {4, 5};
+  int buffer3[4] = {6, 7, 8, 9};
+  Foo nested[2][3][3] = {{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, {{10, 11, 12}, {13, 14, 15}, {16, 17, 18}}};
+
+  {
+    // Test `views::join(v)`
+    ForwardCommonInner inners[3] = {buffer1, buffer2, buffer3};
+    using Result = std::ranges::join_view<std::ranges::ref_view<ForwardCommonInner[3]>>;
+    std::same_as<Result> auto v = std::views::join(inners);
+    assert(std::ranges::next(v.begin(), 9) == v.end());
+    assert(&(*v.begin()) == buffer1);
+  }
+  {
+    // Test `views::join(move-only-view)`
+    ForwardCommonInner inners[3] = {buffer1, buffer2, buffer3};
+    using Result = std::ranges::join_view<MoveOnlyOuter>;
+    std::same_as<Result> auto v = std::views::join(MoveOnlyOuter{inners});
+    assert(std::ranges::next(v.begin(), 9) == v.end());
+    assert(&(*v.begin()) == buffer1);
+
+    static_assert(std::invocable<decltype(std::views::join), MoveOnlyOuter>);
+    static_assert(!std::invocable<decltype(std::views::join), MoveOnlyOuter&>);
+  }
+  {
+    // views::join(join_view) should join the view instead of calling copy constructor
+    // LWG3474
+    auto jv = std::views::join(nested);
+    static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(jv)>, Foo(&)[3]>);
+
+    auto jv2 = std::views::join(jv);
+    static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(jv2)>, Foo&>);
+
+    assert(&(*jv2.begin()) == &nested[0][0][0]);
+  }
+
+  {
+    // Test `v | views::join`
+    ForwardCommonInner inners[3] = {buffer1, buffer2, buffer3};
+
+    using Result = std::ranges::join_view<std::ranges::ref_view<ForwardCommonInner[3]>>;
+    std::same_as<Result> auto v = inners | std::views::join;
+    assert(std::ranges::next(v.begin(), 9) == v.end());
+    assert(&(*v.begin()) == buffer1);
+    static_assert(CanBePiped<decltype((inners)), decltype((std::views::join))>);
+  }
+  {
+    // Test `move-only-view | views::join`
+    ForwardCommonInner inners[3] = {buffer1, buffer2, buffer3};
+    using Result = std::ranges::join_view<MoveOnlyOuter>;
+    std::same_as<Result> auto v = MoveOnlyOuter{inners} | std::views::join;
+    assert(std::ranges::next(v.begin(), 9) == v.end());
+    assert(&(*v.begin()) == buffer1);
+
+    static_assert(CanBePiped<MoveOnlyOuter, decltype((std::views::join))>);
+    static_assert(!CanBePiped<MoveOnlyOuter&, decltype((std::views::join))>);
+  }
+  {
+    // join_view | views::join should join the view instead of calling copy constructor
+    // LWG3474
+    auto jv = nested | std::views::join | std::views::join;
+    static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(jv)>, Foo&>);
+
+    assert(&(*jv.begin()) == &nested[0][0][0]);
+    static_assert(CanBePiped<decltype((nested)), decltype((std::views::join))>);
+  }
+
+  {
+    // Test `adaptor | views::join`
+    auto join_twice = std::views::join | std::views::join;
+    auto jv = nested | join_twice;
+    static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(jv)>, Foo&>);
+
+    assert(&(*jv.begin()) == &nested[0][0][0]);
+    static_assert(CanBePiped<decltype((nested)), decltype((join_twice))>);
+  }
+
+  {
+    static_assert(!CanBePiped<int, decltype((std::views::join))>);
+    static_assert(!CanBePiped<Foo, decltype((std::views::join))>);
+    static_assert(!CanBePiped<int(&)[2], decltype((std::views::join))>);
+    static_assert(CanBePiped<int(&)[2][2], decltype((std::views::join))>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.join.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-has-no-incomplete-ranges
 
 // constexpr auto begin();
-// constexpr auto begin() const;
+// constexpr auto begin() const
+//    requires input_­range<const V> &&
+//             is_reference_v<range_reference_t<const V>>;
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "types.h"
 
 struct NonSimpleParentView : std::ranges::view_base {
   ChildView* begin() { return nullptr; }
   const ChildView* begin() const;
   const ChildView* end() const;
 };
 
 struct SimpleParentView : std::ranges::view_base {
   const ChildView* begin() const;
   const ChildView* end() const;
 };
 
+struct ConstNotRange : std::ranges::view_base {
+  const ChildView* begin();
+  const ChildView* end();
+};
+
+template <class T>
+concept HasConstBegin = requires(const T& t) { t.begin(); };
+
 constexpr bool test() {
   int buffer[4][4] = {{1111, 2222, 3333, 4444}, {555, 666, 777, 888}, {99, 1010, 1111, 1212}, {13, 14, 15, 16}};
 
   {
     ChildView children[4] = {ChildView(buffer[0]), ChildView(buffer[1]), ChildView(buffer[2]), ChildView(buffer[3])};
     auto jv = std::ranges::join_view(ParentView{children});
     assert(*jv.begin() == 1111);
   }
constexpr bool test() {
   {
     std::ranges::join_view jv(buffer);
     assert(*jv.begin() == 1111);
   }
 
   {
     const std::ranges::join_view jv(buffer);
     assert(*jv.begin() == 1111);
+    static_assert(HasConstBegin<decltype(jv)>);
+  }
+  {
+    // !input_­range<const V>
+    std::ranges::join_view jv{ConstNotRange{}};
+    static_assert(!HasConstBegin<decltype(jv)>);
+  }
+  {
+    // !is_reference_v<range_reference_t<const V>>
+    auto innerRValueRange = std::views::iota(0, 5) | std::views::transform([](int) { return ChildView{}; });
+    std::ranges::join_view jv{innerRValueRange};
+    static_assert(!HasConstBegin<decltype(jv)>);
   }
-
   // !simple-view<V>
   {
     std::ranges::join_view<NonSimpleParentView> jv;
     static_assert(!std::same_as<decltype(jv.begin()),
                                 decltype(std::as_const(jv).begin())>);
   }
 
   // simple-view<V> && is_reference_v<range_reference_t<V>>;

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

 
 struct BorrowedRange {
   Child *begin() const;
   Child *end() const;
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
 
+struct NestedChildren : std::ranges::view_base {
+  View* begin() const;
+  View* end() const;
+};
+
 void testCTAD() {
     View v;
     Range r;
     BorrowedRange br;
 
     static_assert(std::same_as<
         decltype(std::ranges::join_view(v)),
         std::ranges::join_view<View>
void testCTAD() {
     static_assert(std::same_as<
         decltype(std::ranges::join_view(br)),
         std::ranges::join_view<std::ranges::ref_view<BorrowedRange>>
     >);
     static_assert(std::same_as<
         decltype(std::ranges::join_view(std::move(br))),
         std::ranges::join_view<std::ranges::owning_view<BorrowedRange>>
     >);
+
+    NestedChildren n;
+    std::ranges::join_view jv(n);
+
+    // CTAD generated from the copy constructor instead of joining the join_view
+    static_assert(std::same_as< decltype(std::ranges::join_view(jv)), decltype(jv) >);
+
+    // CTAD generated from the move constructor instead of joining the join_view
+    static_assert(std::same_as< decltype(std::ranges::join_view(std::move(jv))), decltype(jv) >);
 }

libcxx/test/std/ranges/range.adaptors/range.join.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-has-no-incomplete-ranges
 
 // join_view() requires default_initializable<V> = default;
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "types.h"
 
+struct DefaultView : std::ranges::view_base {
+  int i; // deliberately uninitialised
+
+  ChildView* begin() const;
+  ChildView* end() const;
+};
 
 constexpr bool test() {
+  {
     std::ranges::join_view<ParentView<ChildView>> jv;
     assert(std::move(jv).base().ptr_ == globalChildren);
-
+  }
+  {
+    std::ranges::join_view<DefaultView> jv;
+    assert(jv.base().i == 0);
+  }
   static_assert( std::default_initializable<std::ranges::join_view<ParentView<ChildView>>>);
   static_assert(!std::default_initializable<std::ranges::join_view<CopyableParent>>);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/end.pass.cpp

 
 #include <cassert>
 #include <ranges>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "types.h"
 
+template <class T>
+concept HasConstEnd = requires (const T& t){
+  t.end();
+};
+
+
+// | ID | outer  | outer   | outer  | inner | inner   | inner  |     end()     |    end()     |
+// |    | simple | forward | common | l_ref | forward | common |               |    const     |
+// |----|--------|---------|--------|-------|---------|--------|---------------|--------------|
+// | 1  |   Y    |   Y     |   Y    |   Y   |    Y    |   Y    |iterator<true> |iterator<true>|
+// | 2  |   Y    |   Y     |   Y    |   Y   |    Y    |   N    |sentinel<true> |sentinel<true>|
+// | 3  |   Y    |   Y     |   Y    |   Y   |    N    |   Y    |sentinel<true> |sentinel<true>|
+// | 4  |   Y    |   Y     |   Y    |   N   |    Y    |   Y    |sentinel<true> |      -       |
+// | 5  |   Y    |   Y     |   N    |   Y   |    Y    |   Y    |sentinel<true> |sentinel<true>|
+// | 6  |   Y    |   N     |   Y    |   Y   |    Y    |   Y    |sentinel<true> |sentinel<true>|
+// | 7  |   N    |   Y     |   Y    |   Y   |    Y    |   Y    |iterator<false>|iterator<true>|
+// | 8  |   N    |   Y     |   Y    |   Y   |    Y    |   N    |sentinel<false>|sentinel<true>|
+// | 9  |   N    |   Y     |   Y    |   Y   |    N    |   Y    |sentinel<false>|sentinel<true>|
+// | 10 |   N    |   Y     |   Y    |   N   |    Y    |   Y    |sentinel<false>|      -       |
+// | 11 |   N    |   Y     |   N    |   Y   |    Y    |   Y    |sentinel<false>|sentinel<true>|
+// | 12 |   N    |   N     |   Y    |   Y   |    Y    |   Y    |sentinel<false>|sentinel<true>|
+//
+//
+
+struct ConstNotRange : std::ranges::view_base {
+  const ChildView* begin();
+  const ChildView* end();
+};
 
 constexpr bool test() {
   int buffer[4][4] = {{1111, 2222, 3333, 4444}, {555, 666, 777, 888}, {99, 1010, 1111, 1212}, {13, 14, 15, 16}};
 
-  // Non const common, forward range.
   {
-    std::ranges::join_view jv(buffer);
+    // test ID 1
+    ForwardCommonInner inners[4] = {buffer[0], buffer[1], buffer[2], buffer[3]};
+    SimpleForwardCommonOuter<ForwardCommonInner> outer{inners};
+
+    std::ranges::join_view jv(outer);
     assert(jv.end() == std::ranges::next(jv.begin(), 16));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 16));
 
-    static_assert(std::same_as<decltype(jv.end()), decltype(jv.begin())>);
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(std::ranges::common_range<decltype(jv)>);
+    static_assert(std::ranges::common_range<const decltype(jv)>);
   }
+  {
+    // test ID 2
+    ForwardNonCommonInner inners[3] = {buffer[0], buffer[1], buffer[2]};
+    SimpleForwardCommonOuter<ForwardNonCommonInner> outer{inners};
+
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 12));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 12));
     
-  // Non const not common, input range.
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  }
   {
-    ChildView children[4] = {ChildView(buffer[0]), ChildView(buffer[1]), ChildView(buffer[2]), ChildView(buffer[3])};
-    auto jv = std::ranges::join_view(ParentView(children));
-    assert(jv.end() == std::ranges::next(jv.begin(), 16));
+    // test ID 3
+    InputCommonInner inners[3] = {buffer[0], buffer[1], buffer[2]};
+    SimpleForwardCommonOuter<InputCommonInner> outer{inners};
+
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 12));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 12));
 
-    static_assert(!std::same_as<decltype(jv.end()), decltype(jv.begin())>);
-  }
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  } 
+  {
+    // test ID 4
+    ForwardCommonInner inners[2] = {buffer[0], buffer[1]};
+    InnerRValue<SimpleForwardCommonOuter<ForwardCommonInner>> outer{inners};
+
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 8));
 
-  // Const common, forward range.
+    static_assert(!HasConstEnd<decltype(jv)>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  } 
   {
-    const std::ranges::join_view jv(buffer);
+    // test ID 5
+    ForwardCommonInner inners[4] = {buffer[0], buffer[1], buffer[2], buffer[3]};
+    SimpleForwardNonCommonOuter<ForwardCommonInner> outer{inners};
+
+    std::ranges::join_view jv(outer);
     assert(jv.end() == std::ranges::next(jv.begin(), 16));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 16));
 
-    static_assert(std::same_as<decltype(jv.end()), decltype(jv.begin())>);
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
   }
+  {
+    // test ID 6
+    ForwardCommonInner inners[4] = {buffer[0], buffer[1], buffer[2], buffer[3]};
+    SimpleInputCommonOuter<ForwardCommonInner> outer{inners};
 
-  // Const not common, input range.
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 16));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 16));
+
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  }
   {
-    static_assert(std::is_reference_v<std::ranges::range_reference_t<const CopyableParent>>);
+    // test ID 7
+    ForwardCommonInner inners[1] = {buffer[0]};
+    NonSimpleForwardCommonOuter<ForwardCommonInner> outer{inners};
 
-    CopyableChild children[4] = {CopyableChild(buffer[0]), CopyableChild(buffer[1]), CopyableChild(buffer[2]), CopyableChild(buffer[3])};
-    const auto jv = std::ranges::join_view(ParentView(children));
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 4));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 4));
+
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(!std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(std::ranges::common_range<decltype(jv)>);
+    static_assert(std::ranges::common_range<const decltype(jv)>);
+  }
+  {
+    // test ID 8
+    ForwardNonCommonInner inners[3] = {buffer[0], buffer[1], buffer[2]};
+    NonSimpleForwardCommonOuter<ForwardNonCommonInner> outer{inners};
+
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 12));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 12));
+    
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(!std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  }
+  {
+    // test ID 9
+    InputCommonInner inners[3] = {buffer[0], buffer[1], buffer[2]};
+    NonSimpleForwardCommonOuter<InputCommonInner> outer{inners};
+
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 12));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 12));
+
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(!std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  } 
+  {
+    // test ID 10
+    ForwardCommonInner inners[2] = {buffer[0], buffer[1]};
+    InnerRValue<NonSimpleForwardCommonOuter<ForwardCommonInner>> outer{inners};
+
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 8));
+
+    static_assert(!HasConstEnd<decltype(jv)>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  } 
+  {
+    // test ID 11
+    ForwardCommonInner inners[4] = {buffer[0], buffer[1], buffer[2], buffer[3]};
+    NonSimpleForwardNonCommonOuter<ForwardCommonInner> outer{inners};
+
+    std::ranges::join_view jv(outer);
     assert(jv.end() == std::ranges::next(jv.begin(), 16));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 16));
 
-    static_assert(!std::same_as<decltype(jv.end()), decltype(jv.begin())>);
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(!std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
   }
+  {
+    // test ID 12
+    ForwardCommonInner inners[4] = {buffer[0], buffer[1], buffer[2], buffer[3]};
+    NonSimpleInputCommonOuter<ForwardCommonInner> outer{inners};
 
+    std::ranges::join_view jv(outer);
+    assert(jv.end() == std::ranges::next(jv.begin(), 16));
+    assert(std::as_const(jv).end() == std::ranges::next(std::as_const(jv).begin(), 16));
+
+    static_assert(HasConstEnd<decltype(jv)>);
+    static_assert(!std::same_as<decltype(jv.end()), decltype(std::as_const(jv).end())>);
+    static_assert(!std::ranges::common_range<decltype(jv)>);
+    static_assert(!std::ranges::common_range<const decltype(jv)>);
+  }
+  {
+    std::ranges::join_view jv(ConstNotRange{});
+    static_assert(!HasConstEnd<decltype(jv)>);
+  }
   // Has some empty children.
   {
     CopyableChild children[4] = {CopyableChild(buffer[0], 4), CopyableChild(buffer[1], 0), CopyableChild(buffer[2], 1), CopyableChild(buffer[3], 0)};
     auto jv = std::ranges::join_view(ParentView(children));
     assert(jv.end() == std::ranges::next(jv.begin(), 5));
   }
   // Parent is empty.
   {

libcxx/test/std/ranges/range.adaptors/range.join.view/general.pass.cpp

 // General tests for join_view. This file does not test anything specifically.
 
 #include <algorithm>
 #include <cassert>
 #include <ranges>
 #include <string>
 #include <vector>
 
-#include "test_macros.h"
 #include "types.h"
 
-
-template<class R, class I>
-bool isEqual(R &r, I i) {
+template <class R, class I>
+bool isEqual(R& r, I i) {
   for (auto e : r)
     if (e != *i++)
       return false;
   return true;
 }
 
 int main(int, char**) {
   {
     int buffer[4][4] = {{1111, 2222, 3333, 4444}, {555, 666, 777, 888}, {99, 1010, 1111, 1212}, {13, 14, 15, 16}};
-    int *flattened = reinterpret_cast<int*>(buffer);
+    int* flattened = reinterpret_cast<int*>(buffer);
 
     ChildView children[4] = {ChildView(buffer[0]), ChildView(buffer[1]), ChildView(buffer[2]), ChildView(buffer[3])};
     auto jv = std::ranges::join_view(ParentView(children));
     assert(isEqual(jv, flattened));
   }
 
   {
     std::vector<std::string> vec = {"Hello", ",", " ", "World", "!"};
     std::string check = "Hello, World!";
     std::ranges::join_view jv(vec);
     assert(isEqual(jv, check.begin()));
   }
+  {
+    // P2328R1
+    // join a range of prvalue containers
+    std::vector x{1, 2, 3, 4};
+    auto y = x | std::views::transform([](auto i) {
+               std::vector<int> v(i);
+               for (int& ii : v) {
+                 ii = i;
+               }
+               return v;
+             });
+
+    std::ranges::join_view jv(y);
+    std::vector<int> check{1, 2, 2, 3, 3, 3, 4, 4, 4, 4};
+    assert(isEqual(jv, check.begin()));
+  }
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/arrow.pass.cpp

 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // constexpr InnerIter operator->() const
 //   requires has-arrow<InnerIter> && copyable<InnerIter>;
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "../types.h"
 
+template <class Base>
+struct arrow_input_iter {
+  Base it_;
+
+  using value_type = std::iter_value_t<Base>;
+  using difference_type = std::intptr_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  arrow_input_iter()
+    requires std::default_initializable<Base>
+  = default;
+  constexpr arrow_input_iter(Base it) : it_(std::move(it)) {}
+
+  constexpr arrow_input_iter& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++it_; }
+
+  constexpr std::iter_reference_t<Base> operator*() const { return *it_; }
+  constexpr auto operator->() const { return it_; }
+
+  friend constexpr bool operator==(const arrow_input_iter& x, const arrow_input_iter& y) { return x.it_ == y.it_; }
+};
+
+using ArrowInner = BufferView<arrow_input_iter<Box*>>;
+static_assert(std::ranges::input_range<ArrowInner>);
+static_assert(HasArrow<std::ranges::iterator_t<ArrowInner>>);
+
 constexpr bool test() {
   Box buffer[4][4] = {{{1111}, {2222}, {3333}, {4444}}, {{555}, {666}, {777}, {888}}, {{99}, {1010}, {1111}, {1212}}, {{13}, {14}, {15}, {16}}};
 
   {
     // Copyable input iterator with arrow.
     ValueView<Box> children[4] = {ValueView(buffer[0]), ValueView(buffer[1]), ValueView(buffer[2]), ValueView(buffer[3])};
     std::ranges::join_view jv(ValueView<ValueView<Box>>{children});
     assert(jv.begin()->x == 1111);
+    static_assert(HasArrow<decltype(jv.begin())>);
   }
 
   {
     std::ranges::join_view jv(buffer);
     assert(jv.begin()->x == 1111);
+    static_assert(HasArrow<decltype(jv.begin())>);
   }
 
   {
     const std::ranges::join_view jv(buffer);
     assert(jv.begin()->x == 1111);
+    static_assert(HasArrow<decltype(jv.begin())>);
   }
 
+  {
+    // has-arrow<InnerIter> && !copyable<InnerIter>
+    static_assert(HasArrow<move_only_input_iter<int*>>);
+    MoveOnlyIterInner inners[2] = {buffer[0], buffer[1]};
+    std::ranges::join_view jv{inners};
+    static_assert(HasArrow<decltype(std::ranges::begin(inners[0]))>);
+    static_assert(!HasArrow<decltype(jv.begin())>);
+  }
+
+  {
+    // !has-arrow<InnerIter> && copyable<InnerIter>
+    using Inner = BufferView<forward_iterator<Box*>>;
+    Inner inners[2] = {buffer[0], buffer[1]};
+    std::ranges::join_view jv{inners};
+    static_assert(!HasArrow<decltype(std::ranges::begin(inners[0]))>);
+    static_assert(!HasArrow<decltype(jv.begin())>);
+  }
+
+  {
+    // arrow returns inner iterator
+    ArrowInner inners[2] = {buffer[0], buffer[1]};
+    std::ranges::join_view jv{inners};
+    static_assert(HasArrow<decltype(std::ranges::begin(inners[0]))>);
+    static_assert(HasArrow<decltype(jv.begin())>);
+
+    auto jv_it = jv.begin();
+    std::same_as<arrow_input_iter<Box*>> auto arrow_it = jv_it.operator->();
+    assert(arrow_it->x == 1111);
+  }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.other.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-has-no-incomplete-ranges
 
-// constexpr iterator(iterator<!Const> i);
+// constexpr iterator(iterator<!Const> i)
+//             requires Const &&
+//                      convertible_­to<iterator_t<V>, OuterIter> &&
+//                      convertible_­to<iterator_t<InnerRng>, InnerIter>;
 
 #include <cassert>
 #include <ranges>
 
 #include "test_macros.h"
 #include "../types.h"
 
+using ConstCompatibleInner = BufferView<int*>;
+
+using ConstIncompatibleInner = BufferView<forward_iterator<const int*>, forward_iterator<const int*>,
+                                          bidirectional_iterator<int*>, bidirectional_iterator<int*>>;
+
+template <class Inner>
+using ConstCompatibleOuter = BufferView<const Inner*, const Inner*, Inner*, Inner*>;
+
+template <class Inner>
+using ConstIncompatibleOuter = BufferView<forward_iterator<const Inner*>, forward_iterator<const Inner*>,
+                                          bidirectional_iterator<Inner*>, bidirectional_iterator<Inner*>>;
+
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
-
-  CopyableChild children[4] = {CopyableChild(buffer[0]), CopyableChild(buffer[1]), CopyableChild(buffer[2]), CopyableChild(buffer[3])};
+  {
+    CopyableChild children[4] = {CopyableChild(buffer[0]), CopyableChild(buffer[1]), CopyableChild(buffer[2]),
+                                 CopyableChild(buffer[3])};
     std::ranges::join_view jv(CopyableParent{children});
     auto iter1 = jv.begin();
-  std::ranges::iterator_t<const decltype(jv)> iter2 = iter1;
+    using iterator = decltype(iter1);
+    using const_iterator = decltype(std::as_const(jv).begin());
+    static_assert(!std::is_same_v<iterator, const_iterator>);
+    const_iterator iter2 = iter1;
     assert(iter1 == iter2);
 
+    static_assert(std::constructible_from<const_iterator, iterator>);
     // We cannot create a non-const iterator from a const iterator.
-  static_assert(!std::constructible_from<decltype(iter1), decltype(iter2)>);
+    static_assert(!std::constructible_from<iterator, const_iterator>);
+  }
+  {
+    // !convertible_to<inner_iterator, inner_const_iterator>>;
+    ConstIncompatibleInner inners[2] = {buffer[0], buffer[1]};
+    ConstCompatibleOuter<ConstIncompatibleInner> outer{inners};
+    std::ranges::join_view jv(outer);
+    using iterator = decltype(jv.begin());
+    using const_iterator = decltype(std::as_const(jv).begin());
+    static_assert(!std::is_same_v<iterator, const_iterator>);
+
+    static_assert(!std::constructible_from<const_iterator, iterator>);
+    static_assert(!std::constructible_from<iterator, const_iterator>);
+  }
+  {
+    // !convertible_to<outer_iterator, outer_const_iterator>>;
+    ConstCompatibleInner inners[2] = {buffer[0], buffer[1]};
+    ConstIncompatibleOuter<ConstCompatibleInner> outer{inners};
+    std::ranges::join_view jv(outer);
+    using iterator = decltype(jv.begin());
+    using const_iterator = decltype(std::as_const(jv).begin());
+    static_assert(!std::is_same_v<iterator, const_iterator>);
 
+    static_assert(!std::constructible_from<const_iterator, iterator>);
+    static_assert(!std::constructible_from<iterator, const_iterator>);
+  }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.parent.outer.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-has-no-incomplete-ranges
 
 // constexpr iterator(Parent& parent, OuterIter outer);
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "../types.h"
 
+using NonDefaultIter = cpp20_input_iterator<int*>;
+static_assert(!std::default_initializable<NonDefaultIter>);
+
+using NonDefaultIterView = BufferView<NonDefaultIter, sentinel_wrapper<NonDefaultIter>>;
+static_assert(std::ranges::input_range<NonDefaultIterView>);
+
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
-
-  CopyableChild children[4] = {CopyableChild(buffer[0]), CopyableChild(buffer[1]), CopyableChild(buffer[2]), CopyableChild(buffer[3])};
+  {
+    CopyableChild children[4] = {CopyableChild(buffer[0]), CopyableChild(buffer[1]), CopyableChild(buffer[2]),
+                                 CopyableChild(buffer[3])};
     CopyableParent parent{children};
     std::ranges::join_view jv(parent);
     std::ranges::iterator_t<decltype(jv)> iter(jv, std::ranges::begin(parent));
     assert(*iter == 1);
+  }
+
+  {
+    // LWG 3569 Inner iterator not default_initializable
+    NonDefaultIterView inners[2] = {buffer[0], buffer[1]};
+    auto outer = std::views::all(inners);
+    std::ranges::join_view jv(outer);
+    std::ranges::iterator_t<decltype(jv)> iter(jv, std::ranges::begin(outer));
+    assert(*iter == 1);
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.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-has-no-incomplete-ranges
 
 // constexpr iterator& operator--();
+//              requires ref-is-glvalue && bidirectional_­range<Base> &&
+//                       bidirectional_­range<range_reference_t<Base>> &&
+//                       common_­range<range_reference_t<Base>>;
 // constexpr iterator operator--(int);
+//              requires ref-is-glvalue && bidirectional_­range<Base> &&
+//                       bidirectional_­range<range_reference_t<Base>> &&
+//                       common_­range<range_reference_t<Base>>;
 
 #include <cassert>
 #include <ranges>
+#include <type_traits>
 
-#include "test_macros.h"
 #include "../types.h"
 
+template <class T>
+concept CanPreDecrement = requires(T& t) { --t; };
+
+template <class T>
+concept CanPostDecrement = requires(T& t) { t--; };
+
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
 
   {
     // outer == ranges::end
     std::ranges::join_view jv(buffer);
     auto iter = std::next(jv.begin(), 16);
     for (int i = 16; i != 0; --i) {
constexpr bool test() {
   {
     int small[2][1] = {{1}, {2}};
     std::ranges::join_view jv(small);
     auto iter = std::next(jv.begin(), 2);
     for (int i = 2; i != 0; --i) {
       assert(*--iter == i);
     }
   }
+  {
+#if defined(__GNUG__) && !defined(__clang__)
+    if (!std::is_constant_evaluated()) {
+#endif
+      // skip empty inner
+      BidiCommonInner inners[4] = {buffer[0], {nullptr, 0}, {nullptr, 0}, buffer[1]};
+      std::ranges::join_view jv(inners);
+      auto iter = jv.end();
+      for (int i = 8; i != 0; --i) {
+        assert(*--iter == i);
+      }
+#if defined(__GNUG__) && !defined(__clang__)
+    }
+#endif
+  }
+  {
+    // basic type checking
+    std::ranges::join_view jv(buffer);
+    auto iter1 = std::ranges::next(jv.begin(), 4);
+    using iterator = decltype(iter1);
+
+    std::same_as<iterator&> decltype(auto) iter2 = --iter1;
+    assert(&iter1 == &iter2);
+
+    std::same_as<iterator> decltype(auto) iter3 = iter1--;
+    assert(iter3 == std::next(iter1));
+  }
+  {
+    // !ref-is-glvalue
+    BidiCommonInner inners[2] = {buffer[0], buffer[1]};
+    InnerRValue<BidiCommonOuter<BidiCommonInner>> outer{inners};
+    std::ranges::join_view jv(outer);
+    auto iter = jv.begin();
+    static_assert(!CanPreDecrement<decltype(iter)>);
+    static_assert(!CanPostDecrement<decltype(iter)>);
+  }
+  {
+    // !bidirectional_­range<Base>
+    BidiCommonInner inners[2] = {buffer[0], buffer[1]};
+    SimpleForwardCommonOuter<BidiCommonInner> outer{inners};
+    std::ranges::join_view jv(outer);
+    auto iter = jv.begin();
+    static_assert(!CanPreDecrement<decltype(iter)>);
+    static_assert(!CanPostDecrement<decltype(iter)>);
+  }
+  {
+    // !bidirectional_­range<range_reference_t<Base>>
+    ForwardCommonInner inners[2] = {buffer[0], buffer[1]};
+    std::ranges::join_view jv(inners);
+    auto iter = jv.begin();
+    static_assert(!CanPreDecrement<decltype(iter)>);
+    static_assert(!CanPostDecrement<decltype(iter)>);
+  }
+  {
+    // !common_­range<range_reference_t<Base>>
+    BidiNonCommonInner inners[2] = {buffer[0], buffer[1]};
+    std::ranges::join_view jv(inners);
+    auto iter = jv.begin();
+    static_assert(!CanPreDecrement<decltype(iter)>);
+    static_assert(!CanPostDecrement<decltype(iter)>);
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.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-has-no-incomplete-ranges
 
 // friend constexpr bool operator==(const iterator& x, const iterator& y);
+//          requires ref-is-glvalue && equality_comparable<iterator_t<Base>> &&
+//                   equality_comparable<iterator_t<range_reference_t<Base>>>;
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
-
+  {
     std::ranges::join_view jv(buffer);
     auto iter1 = jv.begin();
     auto iter2 = jv.begin();
     assert(iter1 == iter2);
     iter1++;
     assert(iter1 != iter2);
     iter2++;
     assert(iter1 == iter2);
 
+    assert(jv.begin() == std::as_const(jv).begin());
+  }
+  {
+    // !ref-is-glvalue
+    BidiCommonInner inners[2] = {buffer[0], buffer[1]};
+    InnerRValue<BidiCommonOuter<BidiCommonInner>> outer{inners};
+    std::ranges::join_view jv(outer);
+    auto iter = jv.begin();
+    static_assert(!std::equality_comparable<decltype(iter)>);
+  }
+  {
+    // !equality_comparable<iterator_t<Base>>
+    using Inner = BufferView<int*>;
+    using Outer = BufferView<cpp20_input_iterator<Inner*>, sentinel_wrapper<cpp20_input_iterator<Inner*>>>;
+    static_assert(!std::equality_comparable<std::ranges::iterator_t<Outer>>);
+    Inner inners[2] = {buffer[0], buffer[1]};
+    std::ranges::join_view jv(Outer{inners});
+    auto iter = jv.begin();
+    static_assert(!std::equality_comparable<decltype(iter)>);
+    auto const_iter = std::as_const(jv).begin();
+    static_assert(!std::equality_comparable<decltype(const_iter)>);
+  }
+  {
+    // !equality_comparable<iterator_t<range_reference_t<Base>>>;
+    using Inner = BufferView<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>;
+    Inner inners[1] = {buffer[0]};
+    std::ranges::join_view jv{inners};
+    auto iter = jv.begin();
+    static_assert(!std::equality_comparable<decltype(iter)>);
+    auto const_iter = std::as_const(jv).begin();
+    static_assert(!std::equality_comparable<decltype(const_iter)>);
+  }
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.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-has-no-incomplete-ranges
 
 // constexpr iterator& operator++();
 // constexpr void operator++(int);
-// constexpr iterator operator++(int);
+// constexpr iterator operator++(int)
+//            requires ref-is-glvalue && forward_­range<Base> &&
+//                     forward_range<range_reference_t<Base>>;
 
 #include <cassert>
 #include <ranges>
 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
// operator++();
     std::ranges::join_view jv(ValueView<ValueView<int>>{children});
     auto iter = jv.begin();
     for (int i = 2; i < 17; ++i) {
       assert(*++iter == i);
     }
 
     ASSERT_SAME_TYPE(decltype(++iter), decltype(iter)&);
   }
+  {
+    // check return value
+    std::ranges::join_view jv(buffer1);
+    auto iter = jv.begin();
+    using iterator = decltype(iter);
+
+    std::same_as<iterator&> decltype(auto) iter2 = ++iter;
+    assert(&iter2 == &iter);
+
+    std::same_as<iterator> decltype(auto) iter3 = iter++;
+    assert(std::next(iter3) == iter);
+  }
+  {
+    // !ref-is-glvalue
+    BidiCommonInner inners[2] = {buffer1[0], buffer1[1]};
+    InnerRValue<BidiCommonOuter<BidiCommonInner>> outer{inners};
+    std::ranges::join_view jv(outer);
+    auto iter = jv.begin();
+    static_assert(std::is_void_v<decltype(iter++)>);
+  }
+  {
+    // !forward_­range<Base>
+    BufferView<int*> inners[2] = {buffer1[0], buffer1[1]};
+    using Outer = SimpleInputCommonOuter<BufferView<int*>>;
+    std::ranges::join_view jv{Outer(inners)};
+    auto iter = jv.begin();
+    static_assert(std::is_void_v<decltype(iter++)>);
+  }
+  {
+    // !forward_range<range_reference_t<Base>>
+    InputCommonInner inners[1] = {buffer1[0]};
+    std::ranges::join_view jv{inners};
+    auto iter = jv.begin();
+    static_assert(std::is_void_v<decltype(iter++)>);
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // friend constexpr decltype(auto) iter_move(const iterator& i);
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
 
+  {
     std::ranges::join_view jv(buffer);
     assert(std::ranges::iter_move(jv.begin()) == 1);
-  ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(jv.begin())), int&&);
+    static_assert(std::is_same_v<decltype(std::ranges::iter_move(jv.begin())), int&&>);
 
     static_assert(noexcept(std::ranges::iter_move(std::declval<decltype(jv.begin())>())));
-
+  }
+  {
+    // iter_move calls inner's iter_move
+    IterMoveSwapAwareView inners[2] = {buffer[0], buffer[1]};
+    std::ranges::join_view jv(inners);
+    auto it = jv.begin();
+
+    const auto& iter_move_called_times1 = jv.base().begin()->iter_move_called;
+    const auto& iter_move_called_times2 = std::next(jv.base().begin())->iter_move_called;
+    assert(iter_move_called_times1 == 0);
+    assert(iter_move_called_times2 == 0);
+
+    std::same_as<std::tuple<int&&>> decltype(auto) x = std::ranges::iter_move(it);
+    assert(std::get<0>(x) == 1);
+    assert(iter_move_called_times1 == 1);
+    assert(iter_move_called_times2 == 0);
+
+    auto it2 = std::ranges::next(it, 4);
+
+    std::same_as<std::tuple<int&&>> decltype(auto) y = std::ranges::iter_move(it2);
+    assert(std::get<0>(y) == 5);
+    assert(iter_move_called_times1 == 1);
+    assert(iter_move_called_times2 == 1);
+  }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/iter.swap.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-has-no-incomplete-ranges
 
 // friend constexpr void iter_swap(const iterator& x, const iterator& y);
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
 
+  {
     std::ranges::join_view jv(buffer);
     auto iter1 = jv.begin();
     auto iter2 = std::next(jv.begin());
-  assert(*iter1 == 1);
-  assert(*iter2 == 2);
-  std::ranges::swap(iter1, iter2);
-  assert(*iter1 == 2);
-  assert(*iter2 == 1);
+    assert(buffer[0][0] == 1);
+    assert(buffer[0][1] == 2);
+    std::ranges::iter_swap(iter1, iter2);
+    assert(buffer[0][0] == 2);
+    assert(buffer[0][1] == 1);
 
     static_assert(noexcept(std::ranges::iter_swap(iter1, iter2)));
-
+  }
+  {
+    // iter_move calls inner's iter_swap
+    IterMoveSwapAwareView inners[1] = {buffer[0]};
+    std::ranges::join_view jv(inners);
+    auto it1 = jv.begin();
+    auto it2 = std::ranges::next(it1);
+
+    const auto& iter_swap_called_times = jv.base().begin()->iter_swap_called;
+
+    assert(iter_swap_called_times == 0);
+    assert(buffer[0][0] == 2);
+    assert(buffer[0][1] == 1);
+
+    std::ranges::iter_swap(it1, it2);
+
+    assert(buffer[0][0] == 1);
+    assert(buffer[0][1] == 2);
+    assert(iter_swap_called_times == 1);
+  }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/member_types.compile.pass.cpp

 };
 
 template<class T>
 struct InputView : std::ranges::view_base {
   cpp17_input_iterator<T*> begin() const;
   sentinel_wrapper<cpp17_input_iterator<T*>> end() const;
 };
 
+template <class T, class V>
+struct diff_type_iter {
+  using iterator_category = std::input_iterator_tag;
+  using value_type = V;
+  using difference_type = T;
+
+  V& operator*() const;
+  diff_type_iter& operator++();
+  void operator++(int);
+  friend constexpr bool operator==(diff_type_iter, diff_type_iter) = default;
+};
+
+template <class T, class V = int>
+struct DiffTypeRange : std::ranges::view_base {
+  diff_type_iter<T, V> begin() const;
+  diff_type_iter<T, V> end() const;
+};
+
 template<class T>
 concept HasIterCategory = requires { typename T::iterator_category; };
 
 void test() {
   {
     int buffer[4][4];
     std::ranges::join_view jv(buffer);
     using Iter = std::ranges::iterator_t<decltype(jv)>;
 
-    ASSERT_SAME_TYPE(Iter::iterator_concept, std::bidirectional_iterator_tag);
-    ASSERT_SAME_TYPE(Iter::iterator_category, std::bidirectional_iterator_tag);
-    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
-    ASSERT_SAME_TYPE(Iter::value_type, int);
+    static_assert(std::is_same_v<Iter::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<Iter::iterator_category, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<Iter::value_type, int>);
+    static_assert(HasIterCategory<Iter>);
   }
   {
     using Iter = std::ranges::iterator_t<std::ranges::join_view<ForwardView<ForwardView<int>>>>;
 
-    ASSERT_SAME_TYPE(Iter::iterator_concept, std::forward_iterator_tag);
-    ASSERT_SAME_TYPE(Iter::iterator_category, std::forward_iterator_tag);
-    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
-    ASSERT_SAME_TYPE(Iter::value_type, int);
+    static_assert(std::is_same_v<Iter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::is_same_v<Iter::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::is_same_v<Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<Iter::value_type, int>);
+    static_assert(HasIterCategory<Iter>);
   }
   {
     using Iter = std::ranges::iterator_t<std::ranges::join_view<InputView<InputView<int>>>>;
 
-    ASSERT_SAME_TYPE(Iter::iterator_concept, std::input_iterator_tag);
+    static_assert(std::is_same_v<Iter::iterator_concept, std::input_iterator_tag>);
     static_assert(!HasIterCategory<Iter>);
-    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
-    ASSERT_SAME_TYPE(Iter::value_type, int);
+    static_assert(std::is_same_v<Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<Iter::value_type, int>);
+  }
+  {
+    // !ref-is-glvalue
+    using Outer = InnerRValue<BidiCommonOuter<BidiCommonInner>>;
+    using Iter = std::ranges::iterator_t<std::ranges::join_view<Outer>>;
+    static_assert(!HasIterCategory<Iter>);
+    static_assert(std::is_same_v<Iter::iterator_concept, std::input_iterator_tag>);
+  }
+  {
+    // value_type == inner's value_type
+    using Inner = IterMoveSwapAwareView;
+    using Outer = BidiCommonOuter<Inner>;
+    using Iter = std::ranges::iterator_t<std::ranges::join_view<Outer>>;
+    static_assert(std::is_same_v<std::ranges::range_value_t<Inner>, std::tuple<int>>);
+    static_assert(std::is_same_v<Iter::value_type, std::tuple<int>>);
+  }
+  {
+    // difference_type
+    using Inner = DiffTypeRange<std::intptr_t>;
+    using Outer = DiffTypeRange<std::ptrdiff_t, Inner>;
+    using Iter = std::ranges::iterator_t<std::ranges::join_view<Outer>>;
+    static_assert(std::is_same_v<Iter::difference_type, std::common_type_t<std::intptr_t, std::ptrdiff_t>>);
   }
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/sentinel/ctor.other.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-has-no-incomplete-ranges
 
 // constexpr sentinel(sentinel<!Const> s);
+//             requires Const && convertible_­to<sentinel_t<V>, sentinel_t<Base>>;
 
 #include <cassert>
 #include <ranges>
 
-#include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
-
-  CopyableChild children[4] = {CopyableChild(buffer[0]), CopyableChild(buffer[1]), CopyableChild(buffer[2]), CopyableChild(buffer[3])};
+  {
+    CopyableChild children[4] = {CopyableChild(buffer[0]), CopyableChild(buffer[1]), CopyableChild(buffer[2]),
+                                 CopyableChild(buffer[3])};
     std::ranges::join_view jv(CopyableParent{children});
     auto sent1 = jv.end();
     std::ranges::sentinel_t<const decltype(jv)> sent2 = sent1;
-  (void) sent2; // We can't really do anything with these sentinels now :/
+    assert(std::as_const(jv).begin() != sent2);
+    assert(std::ranges::next(std::as_const(jv).begin(), 16) == sent2);
 
     // We cannot create a non-const iterator from a const iterator.
     static_assert(!std::constructible_from<decltype(sent1), decltype(sent2)>);
-
+  }
+  {
+    using Inner = BufferView<int*>;
+    using ConstIncompatibleOuter =
+        BufferView<forward_iterator<const Inner*>, sentinel_wrapper<forward_iterator<const Inner*>>,
+                   bidirectional_iterator<Inner*>, sentinel_wrapper<bidirectional_iterator<Inner*>>>;
+    using JoinView = std::ranges::join_view<ConstIncompatibleOuter>;
+    using sentinel = std::ranges::sentinel_t<JoinView>;
+    using const_sentinel = std::ranges::sentinel_t<const JoinView>;
+    static_assert(!std::constructible_from<sentinel, const_sentinel>);
+    static_assert(!std::constructible_from<const_sentinel, sentinel>);
+  }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_JOIN_TYPES_H
 #define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_JOIN_TYPES_H
 
 #include <concepts>
+#include <tuple>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 int globalBuffer[4][4] = {{1111, 2222, 3333, 4444}, {555, 666, 777, 888}, {99, 1010, 1111, 1212}, {13, 14, 15, 16}};
 
 struct ChildView : std::ranges::view_base {
   int *ptr_;
struct CopyableChild : std::ranges::view_base {
   constexpr CopyableChild(int *ptr = globalBuffer[0], unsigned size = 4)
     : ptr_(ptr), size_(size) {}
 
   constexpr cpp17_input_iterator<int *> begin() { return cpp17_input_iterator<int *>(ptr_); }
   constexpr cpp17_input_iterator<const int *> begin() const { return cpp17_input_iterator<const int *>(ptr_); }
   constexpr int *end() { return ptr_ + size_; }
   constexpr const int *end() const { return ptr_ + size_; }
 };
 // TODO: remove these bogus operators
 constexpr bool operator==(const cpp17_input_iterator<const int*> &lhs, const int* rhs) { return base(lhs) == rhs; }
 constexpr bool operator==(const int* lhs, const cpp17_input_iterator<const int*> &rhs) { return base(rhs) == lhs; }
 
 struct CopyableParent : std::ranges::view_base {
   CopyableChild *ptr_;
   constexpr CopyableParent(CopyableChild *ptr) : ptr_(ptr) {}
 
   constexpr cpp17_input_iterator<CopyableChild *> begin() { return cpp17_input_iterator<CopyableChild *>(ptr_); }
   constexpr cpp17_input_iterator<const CopyableChild *> begin() const { return cpp17_input_iterator<const CopyableChild *>(ptr_); }
   constexpr CopyableChild *end() { return ptr_ + 4; }
   constexpr const CopyableChild *end() const { return ptr_ + 4; }
struct ValueView : std::ranges::view_base {
   ValueView& operator=(const ValueView&) = delete;
 
   constexpr InputValueIter<T> begin() { return ptr_; }
   constexpr InputValueIter<T> begin() const { return ptr_; }
   constexpr T *end() { return ptr_.ptr_ + 4; }
   constexpr const T *end() const { return ptr_.ptr_ + 4; }
 };
 
+template <class T>
+struct Buffer{
+   T* buffer_;
+   std::size_t size_;
+
+   template <std::size_t N>
+   constexpr Buffer(T (&b)[N]) :buffer_(b), size_(N){}
+   constexpr Buffer(T* p, std::size_t s) : buffer_(p), size_(s){}
+};
+
+template <class Iter, class Sent = Iter, class NonConstIter = Iter, class NonConstSent = Sent>
+struct BufferView : std::ranges::view_base, Buffer<std::iter_value_t<Iter>> {
+  using Buffer<std::iter_value_t<Iter>>::Buffer;
+
+ constexpr NonConstIter begin()
+    requires(!std::is_same_v<Iter, NonConstIter>)
+  {
+    return NonConstIter(this->buffer_);
+  }
+  constexpr Iter begin() const { return Iter(this->buffer_); }
+
+  constexpr NonConstSent end()
+    requires(!std::is_same_v<Sent, NonConstSent>)
+  {
+    if constexpr (std::is_same_v<NonConstIter, NonConstSent>) {
+      return NonConstIter(this->buffer_ + this->size_);
+    } else {
+      return NonConstSent(NonConstIter(this->buffer_ + this->size_));
+    }
+  }
+
+  constexpr Sent end() const {
+    if constexpr (std::is_same_v<Iter, Sent>) {
+      return Iter(this->buffer_ + this->size_);
+    } else {
+      return Sent(Iter(this->buffer_ + this->size_));
+    }
+  }
+};
+
+template <class Base>
+struct common_input_iterator {
+  Base it_;
+
+  using value_type = std::iter_value_t<Base>;
+  using difference_type = std::intptr_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  constexpr common_input_iterator() = default;
+  constexpr explicit common_input_iterator(Base it) : it_(it) {}
+
+  constexpr common_input_iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++it_; }
+
+  constexpr std::iter_reference_t<Base> operator*() const { return *it_; }
+
+  friend constexpr bool operator==(common_input_iterator const&, common_input_iterator const&) = default;
+};
+
+using InputCommonInner = BufferView<common_input_iterator<int*>>;
+static_assert(std::ranges::input_range<InputCommonInner>);
+static_assert(!std::ranges::forward_range<InputCommonInner>);
+static_assert(std::ranges::common_range<InputCommonInner>);
+
+using InputNonCommonInner = BufferView<common_input_iterator<int*>, sentinel_wrapper<common_input_iterator<int*>>>;
+static_assert(std::ranges::input_range<InputNonCommonInner>);
+static_assert(!std::ranges::forward_range<InputNonCommonInner>);
+static_assert(!std::ranges::common_range<InputNonCommonInner>);
+
+using ForwardCommonInner = BufferView<forward_iterator<int*>>;
+static_assert(std::ranges::forward_range<ForwardCommonInner>);
+static_assert(!std::ranges::bidirectional_range<ForwardCommonInner>);
+static_assert(std::ranges::common_range<ForwardCommonInner>);
+
+using ForwardNonCommonInner = BufferView<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>;
+static_assert(std::ranges::forward_range<ForwardNonCommonInner>);
+static_assert(!std::ranges::bidirectional_range<ForwardNonCommonInner>);
+static_assert(!std::ranges::common_range<ForwardNonCommonInner>);
+
+using BidiCommonInner = BufferView<bidirectional_iterator<int*>>;
+static_assert(std::ranges::bidirectional_range<BidiCommonInner>);
+static_assert(std::ranges::common_range<BidiCommonInner>);
+
+using BidiNonCommonInner = BufferView<bidirectional_iterator<int*>, sentinel_wrapper<bidirectional_iterator<int*>>>;
+static_assert(std::ranges::bidirectional_range<BidiNonCommonInner>);
+static_assert(!std::ranges::common_range<BidiNonCommonInner>);
+
+
+template <class Inner = BufferView<int*>>
+using SimpleInputCommonOuter = BufferView<common_input_iterator<Inner*>>;
+static_assert(!std::ranges::forward_range<SimpleInputCommonOuter<>>);
+static_assert(!std::ranges::bidirectional_range<SimpleInputCommonOuter<>>);
+static_assert(std::ranges::common_range<SimpleInputCommonOuter<>>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleInputCommonOuter<>>);
+
+template <class Inner = BufferView<int*>>
+using NonSimpleInputCommonOuter = BufferView<common_input_iterator<const Inner*>, common_input_iterator<const Inner*>,
+                                             common_input_iterator< Inner*>, common_input_iterator< Inner*>>;
+static_assert(!std::ranges::forward_range<NonSimpleInputCommonOuter<>>);
+static_assert(!std::ranges::bidirectional_range<NonSimpleInputCommonOuter<>>);
+static_assert(std::ranges::common_range<NonSimpleInputCommonOuter<>>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleInputCommonOuter<>>);
+
+template <class Inner = BufferView<int*>>
+using SimpleForwardCommonOuter = BufferView<forward_iterator<Inner*>>;
+static_assert(std::ranges::forward_range<SimpleForwardCommonOuter<>>);
+static_assert(!std::ranges::bidirectional_range<SimpleForwardCommonOuter<>>);
+static_assert(std::ranges::common_range<SimpleForwardCommonOuter<>>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleForwardCommonOuter<>>);
+
+template <class Inner = BufferView<int*>>
+using NonSimpleForwardCommonOuter = BufferView<forward_iterator<const Inner*>, forward_iterator<const Inner*>,
+                                               forward_iterator<Inner*>, forward_iterator<Inner*>>;
+static_assert(std::ranges::forward_range<NonSimpleForwardCommonOuter<>>);
+static_assert(!std::ranges::bidirectional_range<NonSimpleForwardCommonOuter<>>);
+static_assert(std::ranges::common_range<NonSimpleForwardCommonOuter<>>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleForwardCommonOuter<>>);
+
+template <class Inner = BufferView<int*>>
+using SimpleForwardNonCommonOuter = BufferView<forward_iterator<Inner*>, sentinel_wrapper<forward_iterator<Inner*>>>;
+static_assert(std::ranges::forward_range<SimpleForwardNonCommonOuter<>>);
+static_assert(!std::ranges::bidirectional_range<SimpleForwardNonCommonOuter<>>);
+static_assert(!std::ranges::common_range<SimpleForwardNonCommonOuter<>>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleForwardNonCommonOuter<>>);
+
+template <class Inner = BufferView<int*>>
+using NonSimpleForwardNonCommonOuter =
+    BufferView<forward_iterator<const Inner*>, sentinel_wrapper<forward_iterator<const Inner*>>,
+               forward_iterator<Inner*>, sentinel_wrapper<forward_iterator<Inner*>>>;
+static_assert(std::ranges::forward_range<NonSimpleForwardNonCommonOuter<>>);
+static_assert(!std::ranges::bidirectional_range<NonSimpleForwardNonCommonOuter<>>);
+static_assert(!std::ranges::common_range<NonSimpleForwardNonCommonOuter<>>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleForwardNonCommonOuter<>>);
+
+template <class Inner = BufferView<int*>>
+using BidiCommonOuter = BufferView<bidirectional_iterator<Inner*>>;
+static_assert(std::ranges::bidirectional_range<BidiCommonOuter<>>);
+static_assert(std::ranges::common_range<BidiCommonOuter<>>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<BidiCommonOuter<>>);
+
+template <class It>
+struct copy_iterator
+{
+    It it_ = It();
+
+    using value_type = typename std::iterator_traits<It>::value_type;
+    using difference_type = typename std::iterator_traits<It>::difference_type;
+    using pointer = typename std::iterator_traits<It>::pointer;
+    using referece = value_type;
+
+    copy_iterator()
+      requires std::default_initializable<It> = default;
+    constexpr copy_iterator(It it) : it_(std::move(it)) {}
+
+    constexpr referece operator*() const {return *it_;}
+
+    constexpr copy_iterator& operator++() {++it_; return *this;}
+    constexpr copy_iterator& operator--() requires std::bidirectional_iterator<It> {--it_; return *this;}
+    constexpr copy_iterator operator++(int)  requires std::forward_iterator<It> {return copy_iterator(it_++);}
+    constexpr void operator++(int) {return it_++;}
+    constexpr copy_iterator operator--(int)  requires std::bidirectional_iterator<It> {return copy_iterator(it_--);}
+
+    friend constexpr bool operator==(const copy_iterator& x, const copy_iterator& y) {
+      return x.it_ == y.it_;
+    }
+    
+};
+
+template <class Outer>
+struct InnerRValue : Outer {
+
+  using iterator = copy_iterator<std::ranges::iterator_t<Outer>>;
+  using const_iterator = copy_iterator<std::ranges::iterator_t<const Outer>>;
+  using sentinel = copy_iterator<std::ranges::sentinel_t<Outer>>;
+  using const_sentinel = copy_iterator<std::ranges::sentinel_t<const Outer>>;
+
+  using Outer::Outer;
+  static_assert(std::ranges::common_range<Outer>,"non-common range is not supported yet");
+
+  constexpr iterator begin() { return Outer::begin(); }
+  constexpr const_iterator begin() const
+    requires std::ranges::range<const Outer>
+  {
+    return Outer::begin();
+  }
+
+  constexpr auto end() {
+      return iterator{Outer::end()};
+  }
+  constexpr auto end() const
+    requires std::ranges::range<const Outer>
+  {
+      return const_iterator{Outer::end()};
+  }
+};
+static_assert(std::ranges::forward_range<InnerRValue<SimpleForwardCommonOuter<>>>);
+static_assert(!std::ranges::bidirectional_range<InnerRValue<SimpleForwardCommonOuter<>>>);
+static_assert(std::ranges::common_range<InnerRValue<SimpleForwardCommonOuter<>>>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<InnerRValue<SimpleForwardCommonOuter<>>>);
+static_assert(!std::is_lvalue_reference_v<std::ranges::range_reference_t<InnerRValue<SimpleForwardCommonOuter<>>>>);
+
+template<class T>
+concept HasArrow = std::input_iterator<T> && (std::is_pointer_v<T> || requires(T i) { i.operator->(); });
+
+template <class Base>
+struct move_only_input_iter {
+  Base it_;
+
+  using value_type = std::iter_value_t<Base>;
+  using difference_type = std::intptr_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  constexpr move_only_input_iter(Base it) : it_(std::move(it)) {}
+  constexpr move_only_input_iter(move_only_input_iter&&) = default;
+  constexpr move_only_input_iter(const move_only_input_iter&) = delete;
+  constexpr move_only_input_iter& operator=(move_only_input_iter&&) = default;
+  constexpr move_only_input_iter& operator=(const move_only_input_iter&) = delete;
+
+  constexpr move_only_input_iter& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++it_; }
+
+  constexpr std::iter_reference_t<Base> operator*() const { return *it_; }
+  constexpr auto operator->() const requires (HasArrow<Base> && std::copyable<Base>) { return it_; }
+};
+static_assert(!std::copyable<move_only_input_iter<int*>>);
+
+template <class Base>
+struct move_iter_sentinel {
+    Base it_;
+    explicit move_iter_sentinel() = default;
+    constexpr  move_iter_sentinel( Base it) : it_(std::move(it)) {}
+    constexpr bool operator==(const move_only_input_iter<Base>& other) const { return it_ == other.it_; }
+};
+static_assert(std::sentinel_for<move_iter_sentinel<int*>,move_only_input_iter<int*>>);
+
+struct MoveOnlyIterInner : BufferView<move_only_input_iter<Box*>, move_iter_sentinel<Box*>>{
+  using BufferView::BufferView;
+
+  using iterator = move_only_input_iter<Box*>;
+  using sentinel = move_iter_sentinel<Box*>;
+
+  iterator begin() const {return buffer_;}
+  sentinel end() const {return sentinel{buffer_ + size_};}
+};
+static_assert(std::ranges::input_range<MoveOnlyIterInner>);
+
+struct move_swap_aware_iter{
+
+  using value_type = std::tuple<int>;
+  using reference = std::tuple<const int&>;
+  using rvalue_reference = std::tuple<int&&>;
+  using difference_type = std::intptr_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  int* iter_move_called;
+  int* iter_swap_called;
+  int* i_;
+
+  constexpr move_swap_aware_iter& operator++() {
+    ++i_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++i_; }
+
+  constexpr reference operator*() const { return reference(*i_); }
+  constexpr friend bool operator==(const move_swap_aware_iter& x, const move_swap_aware_iter& y){
+    return x.i_ == y.i_;
+  }
+
+  constexpr friend rvalue_reference iter_move(const move_swap_aware_iter& x) noexcept {
+    ++(*x.iter_move_called);
+    return rvalue_reference{std::move(*x.i_)};
+  }
+
+  constexpr friend void iter_swap(const move_swap_aware_iter& x, const move_swap_aware_iter& y) noexcept {
+    ++(*x.iter_swap_called);
+    std::swap(*x.i_, *y.i_);
+  }
+};
+
+struct IterMoveSwapAwareView : Buffer<int>, std::ranges::view_base {
+  int iter_move_called = 0;
+  int iter_swap_called = 0;
+  using Buffer<int>::Buffer;
+
+  constexpr auto begin()  { return move_swap_aware_iter{&iter_move_called, &iter_swap_called, buffer_}; }
+
+  constexpr auto end()  {
+    return 
+        move_swap_aware_iter{&iter_move_called, &iter_swap_called, buffer_ + size_};
+  }
+};
+static_assert(std::ranges::input_range<IterMoveSwapAwareView>);
+
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_JOIN_TYPES_H