[libc++][ranges] Implement rbegin, rend, crbegin and crend.

[var-const]

Don't duplicate __can_reverse.

[var-const]

Add a link to the patch to RangesPaper.csv.

[var-const]

libcxx/include/__ranges/access.h

263

"Otherwise, if T is an array type ([term.array.type]) and remove_­all_­extents_­t<T> is an incomplete type, ranges​::​rbegin(E) is ill-formed with no diagnostic required."

270

"Otherwise, if auto(t.rbegin()) is a valid expression whose type models input_­or_­output_­iterator, ranges​::​rbegin(E) is expression-equivalent to auto(t.rbegin())."

278

"Otherwise, if T is a class or enumeration type and auto(rbegin(t)) is a valid expression whose type models input_­or_­output_­iterator with overload resolution performed in a context in which unqualified lookup for rbegin finds only the declarations

void rbegin(auto&) = delete;
void rbegin(const auto&) = delete;

then ranges​::​rbegin(E) is expression-equivalent to auto(rbegin(t)) with overload resolution performed in the above context."

286

"Otherwise, if both ranges​::​begin(t) and ranges​::​end(t) are valid expressions of the same type which models bidirectional_­iterator ([iterator.concept.bidir]), ranges​::​rbegin(E) is expression-equivalent to make_­reverse_­iterator(ranges​::​end(t))."

335

"Otherwise, if T is an array type ([term.array.type]) and remove_­all_­extents_­t<T> is an incomplete type, ranges​::​rend(E) is ill-formed with no diagnostic required."

342

"Otherwise, if auto(t.rend()) is a valid expression whose type models sentinel_­for<decltype(​ranges​::​rbegin(E))> then ranges​::​rend(E) is expression-equivalent to auto(t.rend())."

350

"Otherwise, if T is a class or enumeration type and auto(rend(t)) is a valid expression whose type models sentinel_­for<decltype(ranges​::​rbegin(E))> with overload resolution performed in a context in which unqualified lookup for rend finds only the declarations

void rend(auto&) = delete;
void rend(const auto&) = delete;

then ranges​::​rend(E) is expression-equivalent to auto(rend(t)) with overload resolution performed in the above context."

358

"Otherwise, if both ranges​::​begin(t) and ranges​::​end(t) are valid expressions of the same type which models bidirectional_­iterator ([iterator.concept.bidir]), then ranges​::​rend(E) is expression-equivalent to make_­reverse_­iterator(ranges​::​begin(t))."

libcxx/test/std/ranges/range.access/begin.pass.cpp

108

I reordered class definitions to be in the order in which they are used in the test function.

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

2

Note: these tests are largely copied from begin.pass.cpp (same with rend.pass.cpp).

302

Note: these tests (up to and including testBeginEnd) are new (same in rend.pass.cpp).

[• Quuxplusone]

Thanks for finishing up this clause!

I've reviewed the implementation but not yet the tests. Some significant code comments will lead to adding some extra tests. (And if you find that you want to add analogous regression tests to begin.pass.cpp and end.pass.cpp too, awesome!)

libcxx/include/__ranges/access.h

16

Because of this new dependency (which is probably circular, once we get around to implementing C++20 reverse_iterator), and because the four functions you're adding are basically symmetric with the four in this file, please split them out into a new detail header. I suggest rbegin.h (for rbegin/crbegin) and rend.h (rend/crend) if you can get away with it. If that idea runs into problems for some reason, then I'd be reasonably happy with just raccess.h (by symmetry with access.h).

227–230

Note: This could be arguably more simply expressed as

template <class _Tp>
concept __can_reverse =
  __can_borrow<_Tp> &&
  same_as<iterator_t<_Tp>, sentinel_t<_Tp>> &&
  bidirectional_iterator<iterator_t<_Tp>>;

or even

template <class _Tp>
concept __can_reverse =
  __can_borrow<_Tp> &&
  common_range<_Tp> &&
  bidirectional_iterator<iterator_t<_Tp>>;

However, the way you wrote it is the closest to the Standard's actual wording (why they used that wording, I don't know) and perhaps marginally faster to compile, so, I think whatever you want to do here is fine.

(Alternatively, if you decide to dig into this and discover a way in which either of my rewrites is not equivalent to the Standard's wording, please make sure to add a regression test so that something will fail if we later decide to go with one of those rewrites anyway.)

263

You suggested on D118963 that sizeof(_Tp) != 0 would be better, and I agree with you. Please make the substitution throughout.

Also, please order the overloads in the same order as the bullet points in the Standard, just for the benefit of future readers. http://eel.is/c++draft/range.access#rbegin-2 This is bullet point... uh... wait... actually this isn't one of the points at all! The "bounded array of complete type" case is handled in the Standard by point (2.5).

I suspect you can dig into this and find a situation where your current overload set produces ambiguity. Something like this maybe?

struct Mine {
  friend Mine *rbegin(Mine *p) { return p; }
  friend Mine *rend(Mine *p) { return p; }
};
Mine a[10];
... std::ranges::rbegin(a) ...

If you find such a case (and I would bet money it's possible to find), then please add it as a regression test.

Edit to add: I wonder if std::string[10] is such a case! std::string[10] has an ADL rbegin and rend out of the box.

300

Remove blank line here (and presumably likewise throughout); try to be consistent with the existing code.

[• Quuxplusone]

libcxx/include/__ranges/access.h

286

I believe your __can_reverse needs to include !__unqualified_rbegin<_Tp> && !__member_rbegin<_Tp> &&, or else you need to include them ad-hoc right here. I have a moderate preference for not ad-hoc, even if it means that you'll have to duplicate the concept into a __can_reverse_begin and a __can_reverse_end for use further down.
Please add a regression test that causes overload resolution ambiguity with your current overload set.

287

Attn @ldionne — it's our new policy to start using unadorned std:: in new code, is that right? Or should we keep the _VSTD:: convention in case the release/14.x process discovers an unexpected problem and we need to roll back the #define _VSTD std change?
(Using std:: here is totally fine if it's our policy; I just want to hear a clear "yes" from @ldionne.)

292

You don't need this — do you? Check whether ranges::begin has it, and be consistent with whatever it is that they do.

335

As above: this overload as written is asking for complete types, which should be handled by points (2.4) and (2.5) instead; so remove this overload.

libcxx/test/std/ranges/range.access/begin.pass.cpp

1

These changes to begin.pass.cpp and end.pass.cpp LGTM, but not directly relevant to this PR. I say go ahead and land these two files (assuming that they still pass after rebasing on trunk), and then this PR will get a bit shorter. Thanks for the cleanup!

[• Quuxplusone]

Btw, once the bugs are polished out, I think this would be an obvious candidate to cherry-pick back to release/14.x. It would be really great to be able to say that libc++14 includes all of the iterator CPOs.

@var-const: Please also update libcxx/test/std//library/description/conventions/customization.point.object/cpo.compile.pass.cpp, and git grep rbegin to see if there's any more places that need updating.

[var-const]

Address review feedback

[var-const]

Rebase upon main.

[var-const]

Remove redundant redefinition of __can_borrow.

[var-const]

Run libcxx-generate-files

libcxx/include/__ranges/access.h

16

Done. (Note that in __iterator/, the header structure is access.h/reverse_access.h)

227–230

Thanks for calling it out. For now, I'd prefer to leave this as a copy-paste from the Standard, but I'm interested to play around with whether the two versions are equivalent. I'll let you know what I find.

263

You suggested on D118963 that sizeof(_Tp) != 0 would be better, and I agree with you. Please make the substitution throughout.

Done.

Also, please order the overloads in the same order as the bullet points in the Standard, just for the benefit of future readers. http://eel.is/c++draft/range.access#rbegin-2 This is bullet point... uh... wait... actually this isn't one of the points at all! The "bounded array of complete type" case is handled in the Standard by point (2.5).

Yeah, I was trying to use the same ordering and created an extra clause for handling arrays specifically to satisfy 2.2 (which is otherwise identical to 2.5). Removed it now since like you said it is already handled implicitly.

I suspect you can dig into this and find a situation where your current overload set produces ambiguity.

Hmm, both Mine[10] and std::string[10] compile fine. When I was writing this, I thought there would be no ambiguity because constraints are only checked on functions with the same signature; thus, template argument deduction would always prefer the (_Tp (&)[_Np]) signature over the (_Tp&&) signature, before concepts come into play. I might well be wrong, though.

286

This is a great catch, thanks! Added a test structure (MemberBeginAndRBegin) and made sure it fails without the code change.

287

(Yeah, I did that due to the recent patch/direction to remove _VSTD. Happy to use _VSTD if necessary)

292

It is the same in ranges::begin. I don't know the rationale -- presumably if overload resolution selects a deleted function, it produces a less verbose error than when it cannot find a match.

300

Removed. I don't want to block this patch on this, but in general I prefer to have blank lines. I feel like the opening (or closing) of a namespace and the first (last) element of that namespace don't have any special relationship to warrant grouping them together.

libcxx/test/std/ranges/range.access/begin.pass.cpp

1

Done: https://reviews.llvm.org/D119214.

[• Quuxplusone]

Continues to look pretty much good. Please see what you can do to shorten the tests — 535 lines for rend.pass.cpp seems excessive, for example. I know a big part of that comes from being consistent with the existing end.pass.cpp, though, so it's not a blocker.

libcxx/include/__ranges/rbegin.h

19

You don't need enable_borrowed_range in this file. (Just the borrowed_range concept itself, which comes from concepts.h). enable_borrowed_range.h is the bare-bones "just the trait" header for people who need to specialize the trait but don't care about querying the concept.

I suspect the similar inclusion in __ranges/access.h might also be unused.

21

Can you be more granular than all of <concepts>?

25

86

libcxx/include/__ranges/rend.h

18

also #include <__ranges/rbegin.h>

88

Consider adding a regression test, although maybe that'll end up looking too silly, once you try it.

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

125–129

As in the other review, I'd say that EmptyRBeginMember is redundant with RBeginMemberReturnsInt; consider removing it.

301

remove extra blank line

302

SGTM. Do you have a test for struct EndWithoutBegin { int *end() const; } that proves such a type is not rbegin'able?

365–366

This is an even simpler case, IIUC: both types are iterators, with the same value_type, interconvertible (well, at least in one direction), and yet still they aren't the same type, so the type is not rbegin'able.

I consider FunctionBeginEndDifferentTypes redundant with this test.

383

I consider FunctionBeginEndForwardIterators redundant with MemberBeginEndForwardIterators.

402

I consider FunctionEndOnly redundant with MemberEndOnly (I'd just keep the latter); and I'm not sure that MemberBeginOnly and FunctionBeginOnly are actually testing anything worth testing, since "obviously" one can't get a reverse-iterator-to-end-of-range out of nothing but a begin() method.

libcxx/test/std/ranges/range.access/rend.pass.cpp

445

LGTM, but please also test that

static_assert(std::same_as<std::invoke_result_t<RangeREndT, MemberBeginAndRBegin&>, int*>);

(and not reverse_iterator<int*>). Actually, it would be profitable to replace all your positive std::is_invocable_v assertions with positive std::same_as assertions. It's free test coverage!

[var-const]

Address review feedback.

libcxx/include/__ranges/rbegin.h

19

Right. access.h still needs to keep the include (it uses enable_borrowed_range in the definition of __can_borrow).

21

Done (and it looks like access.h doesn't need <concepts> at all).

libcxx/include/__ranges/rend.h

88

Thanks for catching this! Added two tests structs (NoThrowBeginThrowingEnd and NoThrowEndThrowingBegin).

I think, however, that it has to be just ranges::begin(__t), not std::make_reverse_iterator(ranges::begin(__t)). make_reverse_iterator is not marked noexcept, so IIUC, it will always lead to noexcept(false). At the same time, it doesn't throw any exceptions of its own, thus the actual behavior solely depends on whether ranges::begin(__t) can throw. Does this sound right to you? I can confirm that adding make_reverse_iterator breaks the existing noexcept tests.

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

301

Hmm, this is consistently used in the existing begin/end.pass.cpp tests to separate different groups of test cases (basically, two empty lines after every test function). I don't particularly like the style, but I followed it for consistency. If these are to be removed, they should be removed from the existing tests as well. What do you think?

302

I think MemberEndOnly is the equivalent test.

365–366

Replaced char* with const int*. I'd rather keep bidirectional_iterator for consistency with other test cases.

383

See my comment below re. Function/MemberEndOnly.

402

I don't feel particularly strongly about keeping these. My intention was to make sure that all these incorrect cases are silently SFINAE'd away as opposed to leading to compilation errors (and they come two versions, member and free, because these are handled by different overloads). So the idea is not to make sure that these can't work (which, like you said, is pretty obvious), but rather that they fail in the expected quiet fashion. If you still feel this isn't worth testing, I can remove these.

libcxx/test/std/ranges/range.access/rend.pass.cpp

445

Done.

Actually, it would be profitable to replace all your positive std::is_invocable_v assertions with positive std::same_as assertions. It's free test coverage!

I'm not sure. It does add to the test coverage, but it's also more verbose and, IMO, doesn't reflect the intention quite as well. In any case, if this is to be done, it should also be done in the existing tests, so it seems more suitable for a separate patch.

[• Quuxplusone]

Somehow the size of rend.pass.cpp went up since I complained about its size. ;)
Anyway, once the "noexcept/expression-equivalent" thing is fixed, I think this is good to go.

@ldionne LGTY? Thoughts on cherry-picking into release/14.x so we can say we've got all of [range.access] in 14.x?

libcxx/include/__ranges/rend.h

88

https://eel.is/c++draft/range.access.rbegin#2.5 is 100% clear that ranges::rbegin(t) must be expression-equivalent to std::make_reverse_iterator(ranges::end(t)), which means that the two expressions must have exactly the same noexceptness. If that means that right now today libc++'s ranges::rbegin is never-noexcept, then OK, that's what it means.

And yep,
https://eel.is/c++draft/reverse.iter.nonmember#7
is also clear that it remains conforming, even in C++20, for make_reverse_iterator to be never-noexcept.

The only thing we could do here that would be non-conforming, would be to have make_reverse_iterator non-noexcept and ranges::rbegin noexcept. That's definitely not permitted by the Standard, because it says the two must be expression-equivalent.

So, please do the "you must write it three times" thing for now (i.e. noexcept(noexcept(the-exact-expression-you're-going-to-return))). And please also triple-check the rest of your noexcept-specifications to make sure they're all correct by this logic.

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

402

Yeah, I'd prefer to see them removed. The place for the silent-SFINAE test is end.pass.cpp/begin.pass.cpp, and I'm 99% sure we've got those tests over there.

libcxx/test/std/ranges/range.access/rend.pass.cpp

445

It does add to the test coverage, but it's also more verbose and, IMO, doesn't reflect the intention quite as well

Well, maybe it changes the perceived intention. Instead of a bunch of similar tests — "this invocation compiles, this one doesn't compile..." — it gives us a bunch of similar tests plus a few "outlier" cases — "this invocation gives T, this invocation gives U, this one doesn't even compile, this invocation gives V..."
Anyway, we can defer this to a followup (or whatever).

[ldionne]

In D119057#3308015, @Quuxplusone wrote:

@ldionne LGTY? Thoughts on cherry-picking into release/14.x so we can say we've got all of [range.access] in 14.x?

This would be disabled due to it being incomplete anyway, so I don't see the point in cherry-picking it back to 14.x.

libcxx/include/__ranges/access.h

287

Yes, we can use std::, but thanks for checking.

libcxx/include/__ranges/rbegin.h

29

This should be guarded by HAS_NO_INCOMPLETE_RANGES too (and other headers too).

[• Quuxplusone]

libcxx/include/__ranges/rbegin.h

29

Yes (perhaps), but that's D118736; I think as long as this header is consistent with what we currently do, it's better not to introduce potential churn over it here.

My impression of D118736 is that we're still kinda confused about what we want HAS_NO_INCOMPLETE_RANGES to encompass — I believe in my original PR it would have been included because it's in ranges::; and then in my subsequent tentative proposal it wouldn't have been because it has no ABI implications (no struct layout); and then in your current proposal it would again be included because it's in ranges:: and no std:: concept depends on it. I assume we'll talk about that offline soon. :)

[var-const]

Address review feedback:

• fix noexcept and the return types in the overloads that return std::make_reverse_iterator;
• adjust tests to expect this overload to always not be noexcept;
• remove redundant tests.

libcxx/include/__ranges/rbegin.h

29

My reasoning was pretty much what @Quuxplusone said -- until D118736 lands, I think new code should follow the existing approach. Do you think we should start applying HAS_NO_INCOMPLETE_RANGES now, without waiting for that patch?

libcxx/include/__ranges/rend.h

88

Thanks for the explanation. Made this function, in both rbegin and rend, follow the "write it 3 times" approach (which also meant replacing the return types).

I think the other overloads are fine -- noexcept is exactly the expression being returned, and I think they can get away with returning auto because _LIBCPP_AUTO_CAST is applied to the return type (same as in the existing begin and end).

[philnik]

LGTM when rebased and CI is happy.

libcxx/include/__ranges/rend.h

67–68

I think every where else struct __fn is used.

[• Quuxplusone]

libcxx/include/__ranges/rend.h

67–68

Nice catch! Yes please. @var-const there's one other use of class __fn in __ranges/access.h; if you could drive-by change that to struct (perhaps in a separate one-line commit), that'd be appreciated. :)

88

follow the "write it 3 times" approach (which also meant replacing the return types)

Sorry for my vagueness there; I really intended only the noexcept(noexcept(exactly-expression)) part — I wasn't requesting the -> decltype(exactly-expression) part. I think you should remove the -> decltype part, because:

• Consistency with other CPOs
• If it is needed, then please keep it but write a regression test demonstrating the need; if it's not needed then it should go away

(D115607 is related, in the sense that we might one day choose to consistently use an approach that includes -> decltype, but that's far out of scope for this PR.)

[ldionne]

libcxx/include/__ranges/rbegin.h

29

I agree. I just spoke with Arthur offline and we agreed on what we needed to do -- we'll try to do it, but the burden shouldn't be on this patch.

[var-const]

• replace class __fn with struct __fn (in rend.h and access.h);
• make overloads that return std::make_reverse_iterator return auto, not decltype(expr);
• include reverse_iterator.h in rend.h to hopefully fix the modular build.

libcxx/include/__ranges/rend.h

88

Sure, reverted that part.

[var-const]

Rebase on main (note that it made the changes to begin/end.pass.cpp go away).

[var-const]

Fix the CI.

libcxx/docs/Status/RangesPaper.csv

 | Updates to ostream_iterator
 | Updates to istreambuf_iterator
 | Updates to ostreambuf_iterator
 ",[default.sentinels],Unassigned,Not started
 `[range.access] <https://wg21.link/range.access>`_,"| `ranges::begin <https://llvm.org/D100255>`_
 | `ranges::end <https://llvm.org/D100255>`_
 | `range::cbegin <https://llvm.org/D100255>`_
 | `ranges::cend <https://llvm.org/D100255>`_
-| ranges::rbegin
-| ranges::rend
-| ranges::crbegin
-| ranges::crend
+| `ranges::rbegin <https://llvm.org/D119057>`_
+| `ranges::rend <https://llvm.org/D119057>`_
+| `ranges::crbegin <https://llvm.org/D119057>`_
+| `ranges::crend <https://llvm.org/D119057>`_
 | `ranges::size <https://llvm.org/D101079>`_
 | `ranges::ssize <https://llvm.org/D101189>`_
 | `ranges::empty <https://llvm.org/D101193>`_
 | `ranges::data <https://llvm.org/D101476>`_
-| `ranges::cdata <https://llvm.org/D117044>`_",[iterator.concepts],Christopher Di Bella and Zoe Carver,In progress
+| `ranges::cdata <https://llvm.org/D117044>`_",[iterator.concepts],Various,✅
 `[range.range] <https://wg21.link/range.range>`_,"| `ranges::range <https://llvm.org/D100269>`_
 | `ranges::borrowed_range <https://llvm.org/D102426>`_
 | `ranges::enable_borrowed_range <https://llvm.org/D90999>`_
 | `ranges::iterator_t <https://llvm.org/D100255>`_
 | `ranges::sentinel_t <https://llvm.org/D100269>`_
 | `ranges::range_difference_t <https://llvm.org/D100269>`_
 | `ranges::range_size_t <https://llvm.org/D106708>`_
 | `ranges::range_value_t <https://llvm.org/D100269>`_

libcxx/include/CMakeLists.txt

set(files
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/iota_view.h
   __ranges/join_view.h
   __ranges/non_propagating_cache.h
   __ranges/owning_view.h
   __ranges/range_adaptor.h
+  __ranges/rbegin.h
   __ranges/ref_view.h
+  __ranges/rend.h
   __ranges/reverse_view.h
   __ranges/single_view.h
   __ranges/size.h
   __ranges/subrange.h
   __ranges/take_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __ranges/views.h

libcxx/include/__concepts/class_or_enum.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
 //
 //===----------------------------------------------------------------------===//
 

 #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 // Whether a type is a class type or enumeration type according to the Core wording.
 
 template<class _Tp>
 concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
 
 // Work around Clang bug https://llvm.org/PR52970
+// TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14).
 template<class _Tp>
 concept __workaround_52970 = is_class_v<__uncvref_t<_Tp>> || is_union_v<__uncvref_t<_Tp>>;
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H

libcxx/include/__ranges/access.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_ACCESS_H
 #define _LIBCPP___RANGES_ACCESS_H
 
 #include <__concepts/class_or_enum.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h>
 #include <__ranges/enable_borrowed_range.h>
-#include <__utility/as_const.h>
 #include <__utility/auto_cast.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
inline namespace __cpo {
   inline constexpr auto cend = __cend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_ACCESS_H

libcxx/include/__ranges/rbegin.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___RANGES_RBEGIN_H
+#define _LIBCPP___RANGES_RBEGIN_H
+
+#include <__concepts/class_or_enum.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/readable_traits.h>
+#include <__iterator/reverse_iterator.h>
+#include <__ranges/access.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__utility/auto_cast.h>
+#include <concepts>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [ranges.access.rbegin]
+
+namespace ranges {
+namespace __rbegin {
+template <class _Tp>
+concept __member_rbegin =
+  __can_borrow<_Tp> &&
+  __workaround_52970<_Tp> &&
+  requires(_Tp&& __t) {
+    { _LIBCPP_AUTO_CAST(__t.rbegin()) } -> input_or_output_iterator;
+  };
+
+void rbegin(auto&) = delete;
+void rbegin(const auto&) = delete;
+
+template <class _Tp>
+concept __unqualified_rbegin =
+  !__member_rbegin<_Tp> &&
+  __can_borrow<_Tp> &&
+  __class_or_enum<remove_cvref_t<_Tp>> &&
+  requires(_Tp&& __t) {
+    { _LIBCPP_AUTO_CAST(rbegin(__t)) } -> input_or_output_iterator;
+  };
+
+template <class _Tp>
+concept __can_reverse =
+  __can_borrow<_Tp> &&
+  !__member_rbegin<_Tp> &&
+  !__unqualified_rbegin<_Tp> &&
+  requires(_Tp&& __t) {
+    { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
+    { ranges::begin(__t) } -> bidirectional_iterator;
+  };
+
+struct __fn {
+  template <class _Tp>
+    requires __member_rbegin<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rbegin())))
+  {
+    return _LIBCPP_AUTO_CAST(__t.rbegin());
+  }
+
+  template <class _Tp>
+    requires __unqualified_rbegin<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(rbegin(__t))))
+  {
+    return _LIBCPP_AUTO_CAST(rbegin(__t));
+  }
+
+  template <class _Tp>
+    requires __can_reverse<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(end(__t)))
+  {
+    return std::make_reverse_iterator(ranges::end(__t));
+  }
+
+  void operator()(auto&&) const = delete;
+};
+} // namespace __rbegin
+
+inline namespace __cpo {
+  inline constexpr auto rbegin = __rbegin::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+// [range.access.crbegin]
+
+namespace ranges {
+namespace __crbegin {
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t))))
+    -> decltype(      ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t)))
+    { return          ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(ranges::rbegin(static_cast<const _Tp&&>(__t))))
+    -> decltype(      ranges::rbegin(static_cast<const _Tp&&>(__t)))
+    { return          ranges::rbegin(static_cast<const _Tp&&>(__t)); }
+};
+} // namespace __crbegin
+
+inline namespace __cpo {
+  inline constexpr auto crbegin = __crbegin::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_RBEGIN_H

libcxx/include/__ranges/rend.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___RANGES_REND_H
+#define _LIBCPP___RANGES_REND_H
+
+#include <__concepts/class_or_enum.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/readable_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__utility/auto_cast.h>
+#include <concepts>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [range.access.rend]
+
+namespace ranges {
+namespace __rend {
+template <class _Tp>
+concept __member_rend =
+  __can_borrow<_Tp> &&
+  __workaround_52970<_Tp> &&
+  requires(_Tp&& __t) {
+    ranges::rbegin(__t);
+    { _LIBCPP_AUTO_CAST(__t.rend()) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
+  };
+
+void rend(auto&) = delete;
+void rend(const auto&) = delete;
+
+template <class _Tp>
+concept __unqualified_rend =
+  !__member_rend<_Tp> &&
+  __can_borrow<_Tp> &&
+  __class_or_enum<remove_cvref_t<_Tp>> &&
+  requires(_Tp&& __t) {
+    ranges::rbegin(__t);
+    { _LIBCPP_AUTO_CAST(rend(__t)) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
+  };
+
+template <class _Tp>
+concept __can_reverse =
+  __can_borrow<_Tp> &&
+  !__member_rend<_Tp> &&
+  !__unqualified_rend<_Tp> &&
+  requires(_Tp&& __t) {
+    { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
+    { ranges::begin(__t) } -> bidirectional_iterator;
+  };
+
+class __fn {
+public:
+  template <class _Tp>
+    requires __member_rend<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rend())))
+  {
+    return _LIBCPP_AUTO_CAST(__t.rend());
+  }
+
+  template <class _Tp>
+    requires __unqualified_rend<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(rend(__t))))
+  {
+    return _LIBCPP_AUTO_CAST(rend(__t));
+  }
+
+  template <class _Tp>
+    requires __can_reverse<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(end(__t)))
+  {
+    return std::make_reverse_iterator(ranges::begin(__t));
+  }
+
+  void operator()(auto&&) const = delete;
+};
+} // namespace __rend
+
+inline namespace __cpo {
+  inline constexpr auto rend = __rend::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+// [range.access.crend]
+
+namespace ranges {
+namespace __crend {
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t))))
+    -> decltype(      ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t)))
+    { return          ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(ranges::rend(static_cast<const _Tp&&>(__t))))
+    -> decltype(      ranges::rend(static_cast<const _Tp&&>(__t)))
+    { return          ranges::rend(static_cast<const _Tp&&>(__t)); }
+};
+} // namespace __crend
+
+inline namespace __cpo {
+  inline constexpr auto crend = __crend::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_REND_H

libcxx/include/module.modulemap

module __ranges {
       module empty_view             { private header "__ranges/empty_view.h" }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
       module join_view              { private header "__ranges/join_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module owning_view            { private header "__ranges/owning_view.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h" }
+      module rbegin                 { private header "__ranges/rbegin.h" }
       module ref_view               { private header "__ranges/ref_view.h" }
+      module rend                   { private header "__ranges/rend.h" }
       module reverse_view           { private header "__ranges/reverse_view.h" }
       module single_view            { private header "__ranges/single_view.h" }
       module size                   { private header "__ranges/size.h" }
       module subrange               { private header "__ranges/subrange.h" }
       module take_view              { private header "__ranges/take_view.h" }
       module transform_view         {
         private header "__ranges/transform_view.h"
         export functional.__functional.bind_back

libcxx/include/ranges

 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
+#include <__ranges/rbegin.h>
 #include <__ranges/ref_view.h>
+#include <__ranges/rend.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/views.h>

libcxx/test/std/ranges/range.access/begin.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // std::ranges::begin
 // std::ranges::cbegin
 
 #include <ranges>
 
 #include <cassert>
+#include <utility>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 using RangeBeginT = decltype(std::ranges::begin);
 using RangeCBeginT = decltype(std::ranges::cbegin);
 
 static int globalBuff[8];
 
 static_assert(!std::is_invocable_v<RangeBeginT, int (&&)[10]>);
 static_assert( std::is_invocable_v<RangeBeginT, int (&)[10]>);
 static_assert(!std::is_invocable_v<RangeBeginT, int (&&)[]>);
 static_assert( std::is_invocable_v<RangeBeginT, int (&)[]>);
+static_assert(!std::is_invocable_v<RangeCBeginT, int (&&)[10]>);
+static_assert( std::is_invocable_v<RangeCBeginT, int (&)[10]>);
+static_assert(!std::is_invocable_v<RangeCBeginT, int (&&)[]>);
+static_assert( std::is_invocable_v<RangeCBeginT, int (&)[]>);
 
 struct Incomplete;
 static_assert(!std::is_invocable_v<RangeBeginT, Incomplete(&&)[]>);
 static_assert(!std::is_invocable_v<RangeBeginT, const Incomplete(&&)[]>);
 static_assert(!std::is_invocable_v<RangeCBeginT, Incomplete(&&)[]>);
 static_assert(!std::is_invocable_v<RangeCBeginT, const Incomplete(&&)[]>);
 
 static_assert(!std::is_invocable_v<RangeBeginT, Incomplete(&&)[10]>);
constexpr bool testArray() {
 
   BeginMember c[2];
   assert(std::ranges::begin(c) == c);
   assert(std::ranges::cbegin(c) == c);
 
   return true;
 }
 
-struct BeginMemberFunction {
-  int x;
-  constexpr const int *begin() const { return &x; }
-  friend int *begin(BeginMemberFunction const&);
-};
-
 struct BeginMemberReturnsInt {
   int begin() const;
 };
 static_assert(!std::is_invocable_v<RangeBeginT, BeginMemberReturnsInt const&>);
 
 struct BeginMemberReturnsVoidPtr {
   const void *begin() const;
 };
 static_assert(!std::is_invocable_v<RangeBeginT, BeginMemberReturnsVoidPtr const&>);
 
 struct EmptyBeginMember {
   struct iterator {};
   iterator begin() const;
 };
 static_assert(!std::is_invocable_v<RangeBeginT, EmptyBeginMember const&>);
 
-struct EmptyPtrBeginMember {
-  struct Empty {};
-  Empty x;
-  constexpr const Empty *begin() const { return &x; }
-};
-
 struct PtrConvertibleBeginMember {
   struct iterator { operator int*() const; };
   iterator begin() const;
 };
 static_assert(!std::is_invocable_v<RangeBeginT, PtrConvertibleBeginMember const&>);
 
 struct NonConstBeginMember {
   int x;
   constexpr int *begin() { return &x; }
 };
 static_assert( std::is_invocable_v<RangeBeginT,  NonConstBeginMember &>);
 static_assert(!std::is_invocable_v<RangeBeginT,  NonConstBeginMember const&>);
 static_assert(!std::is_invocable_v<RangeCBeginT, NonConstBeginMember &>);
 static_assert(!std::is_invocable_v<RangeCBeginT, NonConstBeginMember const&>);
 
 struct EnabledBorrowingBeginMember {
   constexpr int *begin() const { return &globalBuff[0]; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<EnabledBorrowingBeginMember> = true;
 
+struct BeginMemberFunction {
+  int x;
+  constexpr const int *begin() const { return &x; }
+  friend int *begin(BeginMemberFunction const&);
+};
+
+struct EmptyPtrBeginMember {
+  struct Empty {};
+  Empty x;
+  constexpr const Empty *begin() const { return &x; }
+};
+
 constexpr bool testBeginMember() {
   BeginMember a;
   assert(std::ranges::begin(a) == &a.x);
   assert(std::ranges::cbegin(a) == &a.x);
   static_assert(!std::is_invocable_v<RangeBeginT, BeginMember&&>);
   static_assert(!std::is_invocable_v<RangeCBeginT, BeginMember&&>);
 
   NonConstBeginMember b;
struct BeginFunction {
   friend constexpr const int *begin(BeginFunction const& bf) { return &bf.x; }
 };
 static_assert( std::is_invocable_v<RangeBeginT,  BeginFunction const&>);
 static_assert(!std::is_invocable_v<RangeBeginT,  BeginFunction &&>);
 static_assert(!std::is_invocable_v<RangeBeginT,  BeginFunction &>);
 static_assert( std::is_invocable_v<RangeCBeginT, BeginFunction const&>);
 static_assert( std::is_invocable_v<RangeCBeginT, BeginFunction &>);
 
-struct BeginFunctionWithDataMember {
-  int x;
-  int begin;
-  friend constexpr const int *begin(BeginFunctionWithDataMember const& bf) { return &bf.x; }
+struct BeginFunctionReturnsInt {
+  friend int begin(BeginFunctionReturnsInt const&);
 };
+static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsInt const&>);
 
-struct BeginFunctionWithPrivateBeginMember {
-  int y;
-  friend constexpr const int *begin(BeginFunctionWithPrivateBeginMember const& bf) { return &bf.y; }
-private:
-  const int *begin() const;
+struct BeginFunctionReturnsVoidPtr {
+  friend void *begin(BeginFunctionReturnsVoidPtr const&);
 };
+static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsVoidPtr const&>);
 
-struct BeginFunctionReturnsEmptyPtr {
+struct BeginFunctionReturnsEmpty {
   struct Empty {};
-  Empty x;
-  friend constexpr const Empty *begin(BeginFunctionReturnsEmptyPtr const& bf) { return &bf.x; }
+  friend Empty begin(BeginFunctionReturnsEmpty const&);
+};
+static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsEmpty const&>);
+
+struct BeginFunctionReturnsPtrConvertible {
+  struct iterator { operator int*() const; };
+  friend iterator begin(BeginFunctionReturnsPtrConvertible const&);
 };
+static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsPtrConvertible const&>);
 
 struct BeginFunctionByValue {
   friend constexpr int *begin(BeginFunctionByValue) { return &globalBuff[1]; }
 };
 static_assert(!std::is_invocable_v<RangeCBeginT, BeginFunctionByValue>);
 
 struct BeginFunctionEnabledBorrowing {
   friend constexpr int *begin(BeginFunctionEnabledBorrowing) { return &globalBuff[2]; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BeginFunctionEnabledBorrowing> = true;
 
-struct BeginFunctionReturnsInt {
-  friend int begin(BeginFunctionReturnsInt const&);
-};
-static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsInt const&>);
-
-struct BeginFunctionReturnsVoidPtr {
-  friend void *begin(BeginFunctionReturnsVoidPtr const&);
+struct BeginFunctionReturnsEmptyPtr {
+  struct Empty {};
+  Empty x;
+  friend constexpr const Empty *begin(BeginFunctionReturnsEmptyPtr const& bf) { return &bf.x; }
 };
-static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsVoidPtr const&>);
 
-struct BeginFunctionReturnsEmpty {
-  struct Empty {};
-  friend Empty begin(BeginFunctionReturnsEmpty const&);
+struct BeginFunctionWithDataMember {
+  int x;
+  int begin;
+  friend constexpr const int *begin(BeginFunctionWithDataMember const& bf) { return &bf.x; }
 };
-static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsEmpty const&>);
 
-struct BeginFunctionReturnsPtrConvertible {
-  struct iterator { operator int*() const; };
-  friend iterator begin(BeginFunctionReturnsPtrConvertible const&);
+struct BeginFunctionWithPrivateBeginMember {
+  int y;
+  friend constexpr const int *begin(BeginFunctionWithPrivateBeginMember const& bf) { return &bf.y; }
+private:
+  const int *begin() const;
 };
-static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsPtrConvertible const&>);
 
 constexpr bool testBeginFunction() {
   BeginFunction a{};
   const BeginFunction aa{};
   static_assert(!std::invocable<RangeBeginT, decltype((a))>);
   assert(std::ranges::cbegin(a) == &a.x);
   assert(std::ranges::begin(aa) == &aa.x);
   assert(std::ranges::cbegin(aa) == &aa.x);

libcxx/test/std/ranges/range.access/end.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // std::ranges::end
 // std::ranges::cend
 
 #include <ranges>
 
 #include <cassert>
+#include <utility>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 using RangeEndT = decltype(std::ranges::end);
 using RangeCEndT = decltype(std::ranges::cend);
 
 static int globalBuff[8];
 
 static_assert(!std::is_invocable_v<RangeEndT, int (&&)[]>);
 static_assert(!std::is_invocable_v<RangeEndT, int (&)[]>);
 static_assert(!std::is_invocable_v<RangeEndT, int (&&)[10]>);
 static_assert( std::is_invocable_v<RangeEndT, int (&)[10]>);
+static_assert(!std::is_invocable_v<RangeCEndT, int (&&)[]>);
+static_assert(!std::is_invocable_v<RangeCEndT, int (&)[]>);
+static_assert(!std::is_invocable_v<RangeCEndT, int (&&)[10]>);
+static_assert( std::is_invocable_v<RangeCEndT, int (&)[10]>);
 
 struct Incomplete;
 static_assert(!std::is_invocable_v<RangeEndT, Incomplete(&&)[]>);
 static_assert(!std::is_invocable_v<RangeEndT, Incomplete(&&)[42]>);
 static_assert(!std::is_invocable_v<RangeCEndT, Incomplete(&&)[]>);
 static_assert(!std::is_invocable_v<RangeCEndT, Incomplete(&&)[42]>);
 
 struct EndMember {
constexpr bool testArray() {
 
   EndMember c[2];
   assert(std::ranges::end(c) == c + 2);
   assert(std::ranges::cend(c) == c + 2);
 
   return true;
 }
 
-struct EndMemberFunction {
-  int x;
-  constexpr const int *begin() const { return nullptr; }
-  constexpr const int *end() const { return &x; }
-  friend constexpr int *end(EndMemberFunction const&);
-};
-
 struct EndMemberReturnsInt {
   int begin() const;
   int end() const;
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, EndMemberReturnsInt const&>);
 
 struct EndMemberReturnsVoidPtr {
   const void *begin() const;
   const void *end() const;
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, EndMemberReturnsVoidPtr const&>);
 
-struct Empty { };
-struct EmptyEndMember {
-  Empty begin() const;
-  Empty end() const;
-};
-struct EmptyPtrEndMember {
-  Empty x;
-  constexpr const Empty *begin() const { return nullptr; }
-  constexpr const Empty *end() const { return &x; }
-};
-
-static_assert(!std::is_invocable_v<RangeEndT, EmptyEndMember const&>);
-
 struct PtrConvertible {
   operator int*() const;
 };
 struct PtrConvertibleEndMember {
   PtrConvertible begin() const;
   PtrConvertible end() const;
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, PtrConvertibleEndMember const&>);
 
 struct NoBeginMember {
   constexpr const int *end();
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, NoBeginMember const&>);
 
 struct NonConstEndMember {
   int x;
   constexpr int *begin() { return nullptr; }
   constexpr int *end() { return &x; }
 };
-
 static_assert( std::is_invocable_v<RangeEndT,  NonConstEndMember &>);
 static_assert(!std::is_invocable_v<RangeEndT,  NonConstEndMember const&>);
 static_assert(!std::is_invocable_v<RangeCEndT, NonConstEndMember &>);
 static_assert(!std::is_invocable_v<RangeCEndT, NonConstEndMember const&>);
 
 struct EnabledBorrowingEndMember {
   constexpr int *begin() const { return nullptr; }
   constexpr int *end() const { return &globalBuff[0]; }
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<EnabledBorrowingEndMember> = true;
 
+struct EndMemberFunction {
+  int x;
+  constexpr const int *begin() const { return nullptr; }
+  constexpr const int *end() const { return &x; }
+  friend constexpr int *end(EndMemberFunction const&);
+};
+
+struct Empty { };
+struct EmptyEndMember {
+  Empty begin() const;
+  Empty end() const;
+};
+static_assert(!std::is_invocable_v<RangeEndT, EmptyEndMember const&>);
+
+struct EmptyPtrEndMember {
+  Empty x;
+  constexpr const Empty *begin() const { return nullptr; }
+  constexpr const Empty *end() const { return &x; }
+};
+
 constexpr bool testEndMember() {
   EndMember a;
   assert(std::ranges::end(a) == &a.x);
   assert(std::ranges::cend(a) == &a.x);
 
   NonConstEndMember b;
   assert(std::ranges::end(b) == &b.x);
   static_assert(!std::is_invocable_v<RangeCEndT, decltype((b))>);

 static_assert(!std::is_invocable_v<RangeEndT, EndFunction &&>);
 
 static_assert( std::is_invocable_v<RangeEndT,  EndFunction const&>);
 static_assert(!std::is_invocable_v<RangeEndT,  EndFunction &&>);
 static_assert(!std::is_invocable_v<RangeEndT,  EndFunction &>);
 static_assert( std::is_invocable_v<RangeCEndT, EndFunction const&>);
 static_assert( std::is_invocable_v<RangeCEndT, EndFunction &>);
 
-struct EndFunctionWithDataMember {
-  int x;
-  int end;
-  friend constexpr const int *begin(EndFunctionWithDataMember const&) { return nullptr; }
-  friend constexpr const int *end(EndFunctionWithDataMember const& bf) { return &bf.x; }
-};
-
-struct EndFunctionWithPrivateEndMember : private EndMember {
-  int y;
-  friend constexpr const int *begin(EndFunctionWithPrivateEndMember const&) { return nullptr; }
-  friend constexpr const int *end(EndFunctionWithPrivateEndMember const& bf) { return &bf.y; }
-};
-
-struct EndFunctionReturnsEmptyPtr {
-  Empty x;
-  friend constexpr const Empty *begin(EndFunctionReturnsEmptyPtr const&) { return nullptr; }
-  friend constexpr const Empty *end(EndFunctionReturnsEmptyPtr const& bf) { return &bf.x; }
-};
-
-struct EndFunctionByValue {
-  friend constexpr int *begin(EndFunctionByValue) { return nullptr; }
-  friend constexpr int *end(EndFunctionByValue) { return &globalBuff[1]; }
-};
-
-static_assert(!std::is_invocable_v<RangeCEndT, EndFunctionByValue>);
-
-struct EndFunctionEnabledBorrowing {
-  friend constexpr int *begin(EndFunctionEnabledBorrowing) { return nullptr; }
-  friend constexpr int *end(EndFunctionEnabledBorrowing) { return &globalBuff[2]; }
-};
-
-template<>
-inline constexpr bool std::ranges::enable_borrowed_range<EndFunctionEnabledBorrowing> = true;
-
 struct EndFunctionReturnsInt {
   friend constexpr int begin(EndFunctionReturnsInt const&);
   friend constexpr int end(EndFunctionReturnsInt const&);
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, EndFunctionReturnsInt const&>);
 
 struct EndFunctionReturnsVoidPtr {
   friend constexpr void *begin(EndFunctionReturnsVoidPtr const&);
   friend constexpr void *end(EndFunctionReturnsVoidPtr const&);
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, EndFunctionReturnsVoidPtr const&>);
 
 struct EndFunctionReturnsEmpty {
   friend constexpr Empty begin(EndFunctionReturnsEmpty const&);
   friend constexpr Empty end(EndFunctionReturnsEmpty const&);
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, EndFunctionReturnsEmpty const&>);
 
 struct EndFunctionReturnsPtrConvertible {
   friend constexpr PtrConvertible begin(EndFunctionReturnsPtrConvertible const&);
   friend constexpr PtrConvertible end(EndFunctionReturnsPtrConvertible const&);
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, EndFunctionReturnsPtrConvertible const&>);
 
 struct NoBeginFunction {
   friend constexpr const int *end(NoBeginFunction const&);
 };
-
 static_assert(!std::is_invocable_v<RangeEndT, NoBeginFunction const&>);
 
+struct EndFunctionByValue {
+  friend constexpr int *begin(EndFunctionByValue) { return nullptr; }
+  friend constexpr int *end(EndFunctionByValue) { return &globalBuff[1]; }
+};
+static_assert(!std::is_invocable_v<RangeCEndT, EndFunctionByValue>);
+
+struct EndFunctionEnabledBorrowing {
+  friend constexpr int *begin(EndFunctionEnabledBorrowing) { return nullptr; }
+  friend constexpr int *end(EndFunctionEnabledBorrowing) { return &globalBuff[2]; }
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<EndFunctionEnabledBorrowing> = true;
+
+struct EndFunctionReturnsEmptyPtr {
+  Empty x;
+  friend constexpr const Empty *begin(EndFunctionReturnsEmptyPtr const&) { return nullptr; }
+  friend constexpr const Empty *end(EndFunctionReturnsEmptyPtr const& bf) { return &bf.x; }
+};
+
+struct EndFunctionWithDataMember {
+  int x;
+  int end;
+  friend constexpr const int *begin(EndFunctionWithDataMember const&) { return nullptr; }
+  friend constexpr const int *end(EndFunctionWithDataMember const& bf) { return &bf.x; }
+};
+
+struct EndFunctionWithPrivateEndMember : private EndMember {
+  int y;
+  friend constexpr const int *begin(EndFunctionWithPrivateEndMember const&) { return nullptr; }
+  friend constexpr const int *end(EndFunctionWithPrivateEndMember const& bf) { return &bf.y; }
+};
+
 struct BeginMemberEndFunction {
   int x;
   constexpr const int *begin() const { return nullptr; }
   friend constexpr const int *end(BeginMemberEndFunction const& bf) { return &bf.x; }
 };
 
 constexpr bool testEndFunction() {
   const EndFunction a{};

libcxx/test/std/ranges/range.access/rbegin.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::rbegin
+// std::ranges::crbegin
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+using RangeRBeginT = decltype(std::ranges::rbegin);
+using RangeCRBeginT = decltype(std::ranges::crbegin);
+
+static int globalBuff[8];
+
+static_assert(!std::is_invocable_v<RangeRBeginT, int (&&)[10]>);
+static_assert( std::is_invocable_v<RangeRBeginT, int (&)[10]>);
+static_assert(!std::is_invocable_v<RangeRBeginT, int (&&)[]>);
+static_assert(!std::is_invocable_v<RangeRBeginT, int (&)[]>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, int (&&)[10]>);
+static_assert( std::is_invocable_v<RangeCRBeginT, int (&)[10]>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, int (&&)[]>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, int (&)[]>);
+
+struct Incomplete;
+
+static_assert(!std::is_invocable_v<RangeRBeginT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeRBeginT, const Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, const Incomplete(&&)[]>);
+
+static_assert(!std::is_invocable_v<RangeRBeginT, Incomplete(&&)[10]>);
+static_assert(!std::is_invocable_v<RangeRBeginT, const Incomplete(&&)[10]>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, Incomplete(&&)[10]>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, const Incomplete(&&)[10]>);
+
+// This case is IFNDR; we handle it SFINAE-friendly.
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeRBeginT, Incomplete(&)[]>);
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeRBeginT, const Incomplete(&)[]>);
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeCRBeginT, Incomplete(&)[]>);
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeCRBeginT, const Incomplete(&)[]>);
+
+// This case is IFNDR; we handle it SFINAE-friendly.
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeRBeginT, Incomplete(&)[10]>);
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeRBeginT, const Incomplete(&)[10]>);
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeCRBeginT, Incomplete(&)[10]>);
+LIBCPP_STATIC_ASSERT(!std::is_invocable_v<RangeCRBeginT, const Incomplete(&)[10]>);
+
+struct RBeginMember {
+  int x;
+  constexpr const int *rbegin() const { return &x; }
+};
+
+// Ensure that we can't call with rvalues with borrowing disabled.
+static_assert( std::is_invocable_v<RangeRBeginT, RBeginMember &>);
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginMember &&>);
+static_assert( std::is_invocable_v<RangeRBeginT, RBeginMember const&>);
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginMember const&&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, RBeginMember &>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, RBeginMember &&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, RBeginMember const&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, RBeginMember const&&>);
+
+constexpr bool testReturnTypes() {
+  {
+    int *x[2];
+    ASSERT_SAME_TYPE(decltype(std::ranges::rbegin(x)), std::reverse_iterator<int**>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::crbegin(x)), std::reverse_iterator<int* const*>);
+  }
+  {
+    int x[2][2];
+    ASSERT_SAME_TYPE(decltype(std::ranges::rbegin(x)), std::reverse_iterator<int(*)[2]>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::crbegin(x)), std::reverse_iterator<const int(*)[2]>);
+  }
+  {
+    struct Different {
+      char*& rbegin();
+      short*& rbegin() const;
+    } x;
+    ASSERT_SAME_TYPE(decltype(std::ranges::rbegin(x)), char*);
+    ASSERT_SAME_TYPE(decltype(std::ranges::crbegin(x)), short*);
+  }
+  return true;
+}
+
+constexpr bool testArray() {
+  int a[2];
+  assert(std::ranges::rbegin(a).base() == a + 2);
+  assert(std::ranges::crbegin(a).base() == a + 2);
+
+  int b[2][2];
+  assert(std::ranges::rbegin(b).base() == b + 2);
+  assert(std::ranges::crbegin(b).base() == b + 2);
+
+  RBeginMember c[2];
+  assert(std::ranges::rbegin(c).base() == c + 2);
+  assert(std::ranges::crbegin(c).base() == c + 2);
+
+  return true;
+}
+
+struct RBeginMemberReturnsInt {
+  int rbegin() const;
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginMemberReturnsInt const&>);
+
+struct RBeginMemberReturnsVoidPtr {
+  const void *rbegin() const;
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginMemberReturnsVoidPtr const&>);
+
+struct EmptyRBeginMember {
+  struct iterator {};
+  iterator rbegin() const;
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, EmptyRBeginMember const&>);
+
+struct PtrConvertibleRBeginMember {
+  struct iterator { operator int*() const; };
+  iterator rbegin() const;
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, PtrConvertibleRBeginMember const&>);
+
+struct NonConstRBeginMember {
+  int x;
+  constexpr int* rbegin() { return &x; }
+};
+static_assert( std::is_invocable_v<RangeRBeginT,  NonConstRBeginMember &>);
+static_assert(!std::is_invocable_v<RangeRBeginT,  NonConstRBeginMember const&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, NonConstRBeginMember &>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, NonConstRBeginMember const&>);
+
+struct EnabledBorrowingRBeginMember {
+  constexpr int *rbegin() const { return globalBuff; }
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<EnabledBorrowingRBeginMember> = true;
+
+struct RBeginMemberFunction {
+  int x;
+  constexpr const int *rbegin() const { return &x; }
+  friend int* rbegin(RBeginMemberFunction const&);
+};
+
+struct EmptyPtrRBeginMember {
+  struct Empty {};
+  Empty x;
+  constexpr const Empty* rbegin() const { return &x; }
+};
+
+constexpr bool testRBeginMember() {
+  RBeginMember a;
+  assert(std::ranges::rbegin(a) == &a.x);
+  assert(std::ranges::crbegin(a) == &a.x);
+  static_assert(!std::is_invocable_v<RangeRBeginT, RBeginMember&&>);
+  static_assert(!std::is_invocable_v<RangeCRBeginT, RBeginMember&&>);
+
+  NonConstRBeginMember b;
+  assert(std::ranges::rbegin(b) == &b.x);
+  static_assert(!std::is_invocable_v<RangeCRBeginT, NonConstRBeginMember&>);
+
+  EnabledBorrowingRBeginMember c;
+  assert(std::ranges::rbegin(c) == globalBuff);
+  assert(std::ranges::crbegin(c) == globalBuff);
+  assert(std::ranges::rbegin(std::move(c)) == globalBuff);
+  assert(std::ranges::crbegin(std::move(c)) == globalBuff);
+
+  RBeginMemberFunction d;
+  assert(std::ranges::rbegin(d) == &d.x);
+  assert(std::ranges::crbegin(d) == &d.x);
+
+  EmptyPtrRBeginMember e;
+  assert(std::ranges::rbegin(e) == &e.x);
+  assert(std::ranges::crbegin(e) == &e.x);
+
+  return true;
+}
+
+
+struct RBeginFunction {
+  int x;
+  friend constexpr const int* rbegin(RBeginFunction const& bf) { return &bf.x; }
+};
+static_assert( std::is_invocable_v<RangeRBeginT,  RBeginFunction const&>);
+static_assert(!std::is_invocable_v<RangeRBeginT,  RBeginFunction &&>);
+static_assert(!std::is_invocable_v<RangeRBeginT,  RBeginFunction &>);
+static_assert( std::is_invocable_v<RangeCRBeginT, RBeginFunction const&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, RBeginFunction &>);
+
+struct RBeginFunctionReturnsInt {
+  friend int rbegin(RBeginFunctionReturnsInt const&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginFunctionReturnsInt const&>);
+
+struct RBeginFunctionReturnsVoidPtr {
+  friend void *rbegin(RBeginFunctionReturnsVoidPtr const&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginFunctionReturnsVoidPtr const&>);
+
+struct RBeginFunctionReturnsEmpty {
+  struct Empty {};
+  friend Empty rbegin(RBeginFunctionReturnsEmpty const&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginFunctionReturnsEmpty const&>);
+
+struct RBeginFunctionReturnsPtrConvertible {
+  struct iterator { operator int*() const; };
+  friend iterator rbegin(RBeginFunctionReturnsPtrConvertible const&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, RBeginFunctionReturnsPtrConvertible const&>);
+
+struct RBeginFunctionByValue {
+  friend constexpr int *rbegin(RBeginFunctionByValue) { return globalBuff + 1; }
+};
+static_assert(!std::is_invocable_v<RangeCRBeginT, RBeginFunctionByValue>);
+
+struct RBeginFunctionEnabledBorrowing {
+  friend constexpr int *rbegin(RBeginFunctionEnabledBorrowing) { return globalBuff + 2; }
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<RBeginFunctionEnabledBorrowing> = true;
+
+struct RBeginFunctionReturnsEmptyPtr {
+  struct Empty {};
+  Empty x;
+  friend constexpr const Empty *rbegin(RBeginFunctionReturnsEmptyPtr const& bf) { return &bf.x; }
+};
+
+struct RBeginFunctionWithDataMember {
+  int x;
+  int rbegin;
+  friend constexpr const int *rbegin(RBeginFunctionWithDataMember const& bf) { return &bf.x; }
+};
+
+struct RBeginFunctionWithPrivateBeginMember {
+  int y;
+  friend constexpr const int *rbegin(RBeginFunctionWithPrivateBeginMember const& bf) { return &bf.y; }
+private:
+  const int *rbegin() const;
+};
+
+constexpr bool testRBeginFunction() {
+  RBeginFunction a{};
+  const RBeginFunction aa{};
+  static_assert(!std::invocable<RangeRBeginT, decltype((a))>);
+  assert(std::ranges::crbegin(a) == &a.x);
+  assert(std::ranges::rbegin(aa) == &aa.x);
+  assert(std::ranges::crbegin(aa) == &aa.x);
+
+  RBeginFunctionByValue b{};
+  const RBeginFunctionByValue bb{};
+  assert(std::ranges::rbegin(b) == globalBuff + 1);
+  assert(std::ranges::crbegin(b) == globalBuff + 1);
+  assert(std::ranges::rbegin(bb) == globalBuff + 1);
+  assert(std::ranges::crbegin(bb) == globalBuff + 1);
+
+  RBeginFunctionEnabledBorrowing c{};
+  const RBeginFunctionEnabledBorrowing cc{};
+  assert(std::ranges::rbegin(std::move(c)) == globalBuff + 2);
+  assert(std::ranges::crbegin(std::move(c)) == globalBuff + 2);
+  assert(std::ranges::rbegin(std::move(cc)) == globalBuff + 2);
+  assert(std::ranges::crbegin(std::move(cc)) == globalBuff + 2);
+
+  RBeginFunctionReturnsEmptyPtr d{};
+  const RBeginFunctionReturnsEmptyPtr dd{};
+  static_assert(!std::invocable<RangeRBeginT, decltype((d))>);
+  assert(std::ranges::crbegin(d) == &d.x);
+  assert(std::ranges::rbegin(dd) == &dd.x);
+  assert(std::ranges::crbegin(dd) == &dd.x);
+
+  RBeginFunctionWithDataMember e{};
+  const RBeginFunctionWithDataMember ee{};
+  static_assert(!std::invocable<RangeRBeginT, decltype((e))>);
+  assert(std::ranges::rbegin(ee) == &ee.x);
+  assert(std::ranges::crbegin(e) == &e.x);
+  assert(std::ranges::crbegin(ee) == &ee.x);
+
+  RBeginFunctionWithPrivateBeginMember f{};
+  const RBeginFunctionWithPrivateBeginMember ff{};
+  static_assert(!std::invocable<RangeRBeginT, decltype((f))>);
+  assert(std::ranges::crbegin(f) == &f.y);
+  assert(std::ranges::rbegin(ff) == &ff.y);
+  assert(std::ranges::crbegin(ff) == &ff.y);
+
+  return true;
+}
+
+
+struct MemberBeginEnd {
+  int b, e;
+  char cb, ce;
+  constexpr bidirectional_iterator<int*> begin() { return bidirectional_iterator<int*>(&b); }
+  constexpr bidirectional_iterator<int*> end() { return bidirectional_iterator<int*>(&e); }
+  constexpr bidirectional_iterator<const char*> begin() const { return bidirectional_iterator<const char*>(&cb); }
+  constexpr bidirectional_iterator<const char*> end() const { return bidirectional_iterator<const char*>(&ce); }
+};
+static_assert( std::is_invocable_v<RangeRBeginT, MemberBeginEnd&>);
+static_assert( std::is_invocable_v<RangeRBeginT, MemberBeginEnd const&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, MemberBeginEnd const&>);
+
+struct FunctionBeginEnd {
+  int b, e;
+  char cb, ce;
+  friend constexpr bidirectional_iterator<int*> begin(FunctionBeginEnd& v) {
+    return bidirectional_iterator<int*>(&v.b);
+  }
+  friend constexpr bidirectional_iterator<int*> end(FunctionBeginEnd& v) { return bidirectional_iterator<int*>(&v.e); }
+  friend constexpr bidirectional_iterator<const char*> begin(const FunctionBeginEnd& v) {
+    return bidirectional_iterator<const char*>(&v.cb);
+  }
+  friend constexpr bidirectional_iterator<const char*> end(const FunctionBeginEnd& v) {
+    return bidirectional_iterator<const char*>(&v.ce);
+  }
+};
+static_assert( std::is_invocable_v<RangeRBeginT, FunctionBeginEnd&>);
+static_assert( std::is_invocable_v<RangeRBeginT, FunctionBeginEnd const&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, FunctionBeginEnd const&>);
+
+struct MemberBeginFunctionEnd {
+  int b, e;
+  char cb, ce;
+  constexpr bidirectional_iterator<int*> begin() { return bidirectional_iterator<int*>(&b); }
+  friend constexpr bidirectional_iterator<int*> end(MemberBeginFunctionEnd& v) {
+    return bidirectional_iterator<int*>(&v.e);
+  }
+  constexpr bidirectional_iterator<const char*> begin() const { return bidirectional_iterator<const char*>(&cb); }
+  friend constexpr bidirectional_iterator<const char*> end(const MemberBeginFunctionEnd& v) {
+    return bidirectional_iterator<const char*>(&v.ce);
+  }
+};
+static_assert( std::is_invocable_v<RangeRBeginT, MemberBeginFunctionEnd&>);
+static_assert( std::is_invocable_v<RangeRBeginT, MemberBeginFunctionEnd const&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, MemberBeginFunctionEnd const&>);
+
+struct FunctionBeginMemberEnd {
+  int b, e;
+  char cb, ce;
+  friend constexpr bidirectional_iterator<int*> begin(FunctionBeginMemberEnd& v) {
+    return bidirectional_iterator<int*>(&v.b);
+  }
+  constexpr bidirectional_iterator<int*> end() { return bidirectional_iterator<int*>(&e); }
+  friend constexpr bidirectional_iterator<const char*> begin(const FunctionBeginMemberEnd& v) {
+    return bidirectional_iterator<const char*>(&v.cb);
+  }
+  constexpr bidirectional_iterator<const char*> end() const { return bidirectional_iterator<const char*>(&ce); }
+};
+static_assert( std::is_invocable_v<RangeRBeginT, FunctionBeginMemberEnd&>);
+static_assert( std::is_invocable_v<RangeRBeginT, FunctionBeginMemberEnd const&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, FunctionBeginMemberEnd const&>);
+
+struct MemberBeginEndDifferentTypes {
+  bidirectional_iterator<int*> begin();
+  bidirectional_iterator<char*> end();
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, MemberBeginEndDifferentTypes&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, MemberBeginEndDifferentTypes&>);
+
+struct FunctionBeginEndDifferentTypes {
+  friend bidirectional_iterator<int*> begin(FunctionBeginEndDifferentTypes&);
+  friend bidirectional_iterator<char*> end(FunctionBeginEndDifferentTypes&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, FunctionBeginEndDifferentTypes&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, FunctionBeginEndDifferentTypes&>);
+
+struct MemberBeginEndForwardIterators {
+  forward_iterator<int*> begin();
+  forward_iterator<int*> end();
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, MemberBeginEndForwardIterators&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, MemberBeginEndForwardIterators&>);
+
+struct FunctionBeginEndForwardIterators {
+  friend forward_iterator<int*> begin(FunctionBeginEndForwardIterators&);
+  friend forward_iterator<int*> end(FunctionBeginEndForwardIterators&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, FunctionBeginEndForwardIterators&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, FunctionBeginEndForwardIterators&>);
+
+struct MemberBeginOnly {
+  bidirectional_iterator<int*> begin();
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, MemberBeginOnly&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, MemberBeginOnly&>);
+
+struct FunctionBeginOnly {
+  friend bidirectional_iterator<int*> begin(FunctionBeginOnly&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, FunctionBeginOnly&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, FunctionBeginOnly&>);
+
+struct MemberEndOnly {
+  bidirectional_iterator<int*> end();
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, MemberEndOnly&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, MemberEndOnly&>);
+
+struct FunctionEndOnly {
+  friend bidirectional_iterator<int*> end(FunctionEndOnly&);
+};
+static_assert(!std::is_invocable_v<RangeRBeginT, FunctionEndOnly&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, FunctionEndOnly&>);
+
+// Make sure there is no clash between the following cases:
+// - the case that handles classes defining member `rbegin` and `rend` functions;
+// - the case that handles classes defining `begin` and `end` functions returning reversible iterators.
+struct MemberBeginAndRBegin {
+  int* begin() const;
+  int* end() const;
+  int* rbegin() const;
+  int* rend() const;
+};
+static_assert( std::is_invocable_v<RangeRBeginT, MemberBeginAndRBegin&>);
+static_assert( std::is_invocable_v<RangeCRBeginT, MemberBeginAndRBegin&>);
+
+constexpr bool testBeginEnd() {
+  MemberBeginEnd a{};
+  const MemberBeginEnd aa{};
+  assert(std::ranges::rbegin(a).base().base() == &a.e);
+  assert(std::ranges::crbegin(a).base().base() == &a.ce);
+  assert(std::ranges::rbegin(aa).base().base() == &aa.ce);
+  assert(std::ranges::crbegin(aa).base().base() == &aa.ce);
+
+  FunctionBeginEnd b{};
+  const FunctionBeginEnd bb{};
+  assert(std::ranges::rbegin(b).base().base() == &b.e);
+  assert(std::ranges::crbegin(b).base().base() == &b.ce);
+  assert(std::ranges::rbegin(bb).base().base() == &bb.ce);
+  assert(std::ranges::crbegin(bb).base().base() == &bb.ce);
+
+  MemberBeginFunctionEnd c{};
+  const MemberBeginFunctionEnd cc{};
+  assert(std::ranges::rbegin(c).base().base() == &c.e);
+  assert(std::ranges::crbegin(c).base().base() == &c.ce);
+  assert(std::ranges::rbegin(cc).base().base() == &cc.ce);
+  assert(std::ranges::crbegin(cc).base().base() == &cc.ce);
+
+  FunctionBeginMemberEnd d{};
+  const FunctionBeginMemberEnd dd{};
+  assert(std::ranges::rbegin(d).base().base() == &d.e);
+  assert(std::ranges::crbegin(d).base().base() == &d.ce);
+  assert(std::ranges::rbegin(dd).base().base() == &dd.ce);
+  assert(std::ranges::crbegin(dd).base().base() == &dd.ce);
+
+  return true;
+}
+
+
+ASSERT_NOEXCEPT(std::ranges::rbegin(std::declval<int (&)[10]>()));
+ASSERT_NOEXCEPT(std::ranges::crbegin(std::declval<int (&)[10]>()));
+
+struct NoThrowMemberBegin {
+  ThrowingIterator<int> rbegin() const noexcept; // auto(t.rbegin()) doesn't throw
+} ntmb;
+static_assert(noexcept(std::ranges::rbegin(ntmb)));
+static_assert(noexcept(std::ranges::crbegin(ntmb)));
+
+struct NoThrowADLBegin {
+  friend ThrowingIterator<int> rbegin(NoThrowADLBegin&) noexcept;  // auto(rbegin(t)) doesn't throw
+  friend ThrowingIterator<int> rbegin(const NoThrowADLBegin&) noexcept;
+} ntab;
+static_assert(noexcept(std::ranges::rbegin(ntab)));
+static_assert(noexcept(std::ranges::crbegin(ntab)));
+
+struct NoThrowMemberBeginReturnsRef {
+  ThrowingIterator<int>& rbegin() const noexcept; // auto(t.rbegin()) may throw
+} ntmbrr;
+static_assert(!noexcept(std::ranges::rbegin(ntmbrr)));
+static_assert(!noexcept(std::ranges::crbegin(ntmbrr)));
+
+struct BeginReturnsArrayRef {
+    auto rbegin() const noexcept -> int(&)[10];
+} brar;
+static_assert(noexcept(std::ranges::rbegin(brar)));
+static_assert(noexcept(std::ranges::crbegin(brar)));
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeRBeginT, Holder<Incomplete>*>);
+static_assert(!std::is_invocable_v<RangeRBeginT, Holder<Incomplete>*&>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, Holder<Incomplete>*>);
+static_assert(!std::is_invocable_v<RangeCRBeginT, Holder<Incomplete>*&>);
+
+int main(int, char**) {
+  static_assert(testReturnTypes());
+
+  testArray();
+  static_assert(testArray());
+
+  testRBeginMember();
+  static_assert(testRBeginMember());
+
+  testRBeginFunction();
+  static_assert(testRBeginFunction());
+
+  testBeginEnd();
+  static_assert(testBeginEnd());
+
+  return 0;
+}

libcxx/test/std/ranges/range.access/rend.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::rend
+// std::ranges::crend
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+using RangeREndT = decltype(std::ranges::rend);
+using RangeCREndT = decltype(std::ranges::crend);
+
+static int globalBuff[8];
+
+static_assert(!std::is_invocable_v<RangeREndT, int (&&)[]>);
+static_assert(!std::is_invocable_v<RangeREndT, int (&)[]>);
+static_assert(!std::is_invocable_v<RangeREndT, int (&&)[10]>);
+static_assert( std::is_invocable_v<RangeREndT, int (&)[10]>);
+static_assert(!std::is_invocable_v<RangeCREndT, int (&&)[]>);
+static_assert(!std::is_invocable_v<RangeCREndT, int (&)[]>);
+static_assert(!std::is_invocable_v<RangeCREndT, int (&&)[10]>);
+static_assert( std::is_invocable_v<RangeCREndT, int (&)[10]>);
+
+struct Incomplete;
+static_assert(!std::is_invocable_v<RangeREndT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeREndT, Incomplete(&&)[42]>);
+static_assert(!std::is_invocable_v<RangeCREndT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeCREndT, Incomplete(&&)[42]>);
+
+struct REndMember {
+  int x;
+  const int* rbegin() const;
+  constexpr const int* rend() const { return &x; }
+};
+
+// Ensure that we can't call with rvalues with borrowing disabled.
+static_assert( std::is_invocable_v<RangeREndT, REndMember&>);
+static_assert(!std::is_invocable_v<RangeREndT, REndMember &&>);
+static_assert( std::is_invocable_v<RangeREndT, REndMember const&>);
+static_assert(!std::is_invocable_v<RangeREndT, REndMember const&&>);
+static_assert( std::is_invocable_v<RangeCREndT, REndMember &>);
+static_assert(!std::is_invocable_v<RangeCREndT, REndMember &&>);
+static_assert( std::is_invocable_v<RangeCREndT, REndMember const&>);
+static_assert(!std::is_invocable_v<RangeCREndT, REndMember const&&>);
+
+constexpr bool testReturnTypes() {
+  {
+    int *x[2];
+    ASSERT_SAME_TYPE(decltype(std::ranges::rend(x)), std::reverse_iterator<int**>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::crend(x)), std::reverse_iterator<int* const*>);
+  }
+
+  {
+    int x[2][2];
+    ASSERT_SAME_TYPE(decltype(std::ranges::rend(x)), std::reverse_iterator<int(*)[2]>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::crend(x)), std::reverse_iterator<const int(*)[2]>);
+  }
+
+  {
+    struct Different {
+      char* rbegin();
+      sentinel_wrapper<char*>& rend();
+      short* rbegin() const;
+      sentinel_wrapper<short*>& rend() const;
+    } x;
+    ASSERT_SAME_TYPE(decltype(std::ranges::rend(x)), sentinel_wrapper<char*>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::crend(x)), sentinel_wrapper<short*>);
+  }
+
+  return true;
+}
+
+constexpr bool testArray() {
+  int a[2];
+  assert(std::ranges::rend(a).base() == a);
+  assert(std::ranges::crend(a).base() == a);
+
+  int b[2][2];
+  assert(std::ranges::rend(b).base() == b);
+  assert(std::ranges::crend(b).base() == b);
+
+  REndMember c[2];
+  assert(std::ranges::rend(c).base() == c);
+  assert(std::ranges::crend(c).base() == c);
+
+  return true;
+}
+
+struct REndMemberReturnsInt {
+  int rbegin() const;
+  int rend() const;
+};
+static_assert(!std::is_invocable_v<RangeREndT, REndMemberReturnsInt const&>);
+
+struct REndMemberReturnsVoidPtr {
+  const void *rbegin() const;
+  const void *rend() const;
+};
+static_assert(!std::is_invocable_v<RangeREndT, REndMemberReturnsVoidPtr const&>);
+
+struct PtrConvertible {
+  operator int*() const;
+};
+struct PtrConvertibleREndMember {
+  PtrConvertible rbegin() const;
+  PtrConvertible rend() const;
+};
+static_assert(!std::is_invocable_v<RangeREndT, PtrConvertibleREndMember const&>);
+
+struct NoRBeginMember {
+  constexpr const int* rend();
+};
+static_assert(!std::is_invocable_v<RangeREndT, NoRBeginMember const&>);
+
+struct NonConstREndMember {
+  int x;
+  constexpr int* rbegin() { return nullptr; }
+  constexpr int* rend() { return &x; }
+};
+static_assert( std::is_invocable_v<RangeREndT,  NonConstREndMember &>);
+static_assert(!std::is_invocable_v<RangeREndT,  NonConstREndMember const&>);
+static_assert(!std::is_invocable_v<RangeCREndT, NonConstREndMember &>);
+static_assert(!std::is_invocable_v<RangeCREndT, NonConstREndMember const&>);
+
+struct EnabledBorrowingREndMember {
+  constexpr int* rbegin() const { return nullptr; }
+  constexpr int* rend() const { return &globalBuff[0]; }
+};
+
+template <>
+inline constexpr bool std::ranges::enable_borrowed_range<EnabledBorrowingREndMember> = true;
+
+struct REndMemberFunction {
+  int x;
+  constexpr const int* rbegin() const { return nullptr; }
+  constexpr const int* rend() const { return &x; }
+  friend constexpr int* rend(REndMemberFunction const&);
+};
+
+struct Empty { };
+struct EmptyEndMember {
+  Empty rbegin() const;
+  Empty rend() const;
+};
+static_assert(!std::is_invocable_v<RangeREndT, EmptyEndMember const&>);
+
+struct EmptyPtrREndMember {
+  Empty x;
+  constexpr const Empty* rbegin() const { return nullptr; }
+  constexpr const Empty* rend() const { return &x; }
+};
+
+constexpr bool testREndMember() {
+  REndMember a;
+  assert(std::ranges::rend(a) == &a.x);
+  assert(std::ranges::crend(a) == &a.x);
+
+  NonConstREndMember b;
+  assert(std::ranges::rend(b) == &b.x);
+  static_assert(!std::is_invocable_v<RangeCREndT, decltype((b))>);
+
+  EnabledBorrowingREndMember c;
+  assert(std::ranges::rend(std::move(c)) == &globalBuff[0]);
+  assert(std::ranges::crend(std::move(c)) == &globalBuff[0]);
+
+  REndMemberFunction d;
+  assert(std::ranges::rend(d) == &d.x);
+  assert(std::ranges::crend(d) == &d.x);
+
+  EmptyPtrREndMember e;
+  assert(std::ranges::rend(e) == &e.x);
+  assert(std::ranges::crend(e) == &e.x);
+
+  return true;
+}
+
+struct REndFunction {
+  int x;
+  friend constexpr const int* rbegin(REndFunction const&) { return nullptr; }
+  friend constexpr const int* rend(REndFunction const& bf) { return &bf.x; }
+};
+
+static_assert( std::is_invocable_v<RangeREndT, REndFunction const&>);
+static_assert(!std::is_invocable_v<RangeREndT, REndFunction &&>);
+
+static_assert( std::is_invocable_v<RangeREndT,  REndFunction const&>);
+static_assert(!std::is_invocable_v<RangeREndT,  REndFunction &&>);
+static_assert(!std::is_invocable_v<RangeREndT,  REndFunction &>);
+static_assert( std::is_invocable_v<RangeCREndT, REndFunction const&>);
+static_assert( std::is_invocable_v<RangeCREndT, REndFunction &>);
+
+struct REndFunctionReturnsInt {
+  friend constexpr int rbegin(REndFunctionReturnsInt const&);
+  friend constexpr int rend(REndFunctionReturnsInt const&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, REndFunctionReturnsInt const&>);
+
+struct REndFunctionReturnsVoidPtr {
+  friend constexpr void* rbegin(REndFunctionReturnsVoidPtr const&);
+  friend constexpr void* rend(REndFunctionReturnsVoidPtr const&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, REndFunctionReturnsVoidPtr const&>);
+
+struct REndFunctionReturnsEmpty {
+  friend constexpr Empty rbegin(REndFunctionReturnsEmpty const&);
+  friend constexpr Empty rend(REndFunctionReturnsEmpty const&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, REndFunctionReturnsEmpty const&>);
+
+struct REndFunctionReturnsPtrConvertible {
+  friend constexpr PtrConvertible rbegin(REndFunctionReturnsPtrConvertible const&);
+  friend constexpr PtrConvertible rend(REndFunctionReturnsPtrConvertible const&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, REndFunctionReturnsPtrConvertible const&>);
+
+struct NoRBeginFunction {
+  friend constexpr const int* rend(NoRBeginFunction const&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, NoRBeginFunction const&>);
+
+struct REndFunctionByValue {
+  friend constexpr int* rbegin(REndFunctionByValue) { return nullptr; }
+  friend constexpr int* rend(REndFunctionByValue) { return &globalBuff[1]; }
+};
+static_assert(!std::is_invocable_v<RangeCREndT, REndFunctionByValue>);
+
+struct REndFunctionEnabledBorrowing {
+  friend constexpr int* rbegin(REndFunctionEnabledBorrowing) { return nullptr; }
+  friend constexpr int* rend(REndFunctionEnabledBorrowing) { return &globalBuff[2]; }
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<REndFunctionEnabledBorrowing> = true;
+
+struct REndFunctionReturnsEmptyPtr {
+  Empty x;
+  friend constexpr const Empty* rbegin(REndFunctionReturnsEmptyPtr const&) { return nullptr; }
+  friend constexpr const Empty* rend(REndFunctionReturnsEmptyPtr const& bf) { return &bf.x; }
+};
+
+struct REndFunctionWithDataMember {
+  int x;
+  int rend;
+  friend constexpr const int* rbegin(REndFunctionWithDataMember const&) { return nullptr; }
+  friend constexpr const int* rend(REndFunctionWithDataMember const& bf) { return &bf.x; }
+};
+
+struct REndFunctionWithPrivateEndMember : private REndMember {
+  int y;
+  friend constexpr const int* rbegin(REndFunctionWithPrivateEndMember const&) { return nullptr; }
+  friend constexpr const int* rend(REndFunctionWithPrivateEndMember const& bf) { return &bf.y; }
+};
+
+struct RBeginMemberEndFunction {
+  int x;
+  constexpr const int* rbegin() const { return nullptr; }
+  friend constexpr const int* rend(RBeginMemberEndFunction const& bf) { return &bf.x; }
+};
+
+constexpr bool testREndFunction() {
+  const REndFunction a{};
+  assert(std::ranges::rend(a) == &a.x);
+  assert(std::ranges::crend(a) == &a.x);
+  REndFunction aa{};
+  static_assert(!std::is_invocable_v<RangeREndT, decltype((aa))>);
+  assert(std::ranges::crend(aa) == &aa.x);
+
+  REndFunctionByValue b;
+  assert(std::ranges::rend(b) == &globalBuff[1]);
+  assert(std::ranges::crend(b) == &globalBuff[1]);
+
+  REndFunctionEnabledBorrowing c;
+  assert(std::ranges::rend(std::move(c)) == &globalBuff[2]);
+  assert(std::ranges::crend(std::move(c)) == &globalBuff[2]);
+
+  const REndFunctionReturnsEmptyPtr d{};
+  assert(std::ranges::rend(d) == &d.x);
+  assert(std::ranges::crend(d) == &d.x);
+  REndFunctionReturnsEmptyPtr dd{};
+  static_assert(!std::is_invocable_v<RangeREndT, decltype((dd))>);
+  assert(std::ranges::crend(dd) == &dd.x);
+
+  const REndFunctionWithDataMember e{};
+  assert(std::ranges::rend(e) == &e.x);
+  assert(std::ranges::crend(e) == &e.x);
+  REndFunctionWithDataMember ee{};
+  static_assert(!std::is_invocable_v<RangeREndT, decltype((ee))>);
+  assert(std::ranges::crend(ee) == &ee.x);
+
+  const REndFunctionWithPrivateEndMember f{};
+  assert(std::ranges::rend(f) == &f.y);
+  assert(std::ranges::crend(f) == &f.y);
+  REndFunctionWithPrivateEndMember ff{};
+  static_assert(!std::is_invocable_v<RangeREndT, decltype((ff))>);
+  assert(std::ranges::crend(ff) == &ff.y);
+
+  const RBeginMemberEndFunction g{};
+  assert(std::ranges::rend(g) == &g.x);
+  assert(std::ranges::crend(g) == &g.x);
+  RBeginMemberEndFunction gg{};
+  static_assert(!std::is_invocable_v<RangeREndT, decltype((gg))>);
+  assert(std::ranges::crend(gg) == &gg.x);
+
+  return true;
+}
+
+
+struct MemberBeginEnd {
+  int b, e;
+  char cb, ce;
+  constexpr bidirectional_iterator<int*> begin() { return bidirectional_iterator<int*>(&b); }
+  constexpr bidirectional_iterator<int*> end() { return bidirectional_iterator<int*>(&e); }
+  constexpr bidirectional_iterator<const char*> begin() const { return bidirectional_iterator<const char*>(&cb); }
+  constexpr bidirectional_iterator<const char*> end() const { return bidirectional_iterator<const char*>(&ce); }
+};
+static_assert( std::is_invocable_v<RangeREndT, MemberBeginEnd&>);
+static_assert( std::is_invocable_v<RangeREndT, MemberBeginEnd const&>);
+static_assert( std::is_invocable_v<RangeCREndT, MemberBeginEnd const&>);
+
+struct FunctionBeginEnd {
+  int b, e;
+  char cb, ce;
+  friend constexpr bidirectional_iterator<int*> begin(FunctionBeginEnd& v) {
+    return bidirectional_iterator<int*>(&v.b);
+  }
+  friend constexpr bidirectional_iterator<int*> end(FunctionBeginEnd& v) { return bidirectional_iterator<int*>(&v.e); }
+  friend constexpr bidirectional_iterator<const char*> begin(const FunctionBeginEnd& v) {
+    return bidirectional_iterator<const char*>(&v.cb);
+  }
+  friend constexpr bidirectional_iterator<const char*> end(const FunctionBeginEnd& v) {
+    return bidirectional_iterator<const char*>(&v.ce);
+  }
+};
+static_assert( std::is_invocable_v<RangeREndT, FunctionBeginEnd&>);
+static_assert( std::is_invocable_v<RangeREndT, FunctionBeginEnd const&>);
+static_assert( std::is_invocable_v<RangeCREndT, FunctionBeginEnd const&>);
+
+struct MemberBeginFunctionEnd {
+  int b, e;
+  char cb, ce;
+  constexpr bidirectional_iterator<int*> begin() { return bidirectional_iterator<int*>(&b); }
+  friend constexpr bidirectional_iterator<int*> end(MemberBeginFunctionEnd& v) {
+    return bidirectional_iterator<int*>(&v.e);
+  }
+  constexpr bidirectional_iterator<const char*> begin() const { return bidirectional_iterator<const char*>(&cb); }
+  friend constexpr bidirectional_iterator<const char*> end(const MemberBeginFunctionEnd& v) {
+    return bidirectional_iterator<const char*>(&v.ce);
+  }
+};
+static_assert( std::is_invocable_v<RangeREndT, MemberBeginFunctionEnd&>);
+static_assert( std::is_invocable_v<RangeREndT, MemberBeginFunctionEnd const&>);
+static_assert( std::is_invocable_v<RangeCREndT, MemberBeginFunctionEnd const&>);
+
+struct FunctionBeginMemberEnd {
+  int b, e;
+  char cb, ce;
+  friend constexpr bidirectional_iterator<int*> begin(FunctionBeginMemberEnd& v) {
+    return bidirectional_iterator<int*>(&v.b);
+  }
+  constexpr bidirectional_iterator<int*> end() { return bidirectional_iterator<int*>(&e); }
+  friend constexpr bidirectional_iterator<const char*> begin(const FunctionBeginMemberEnd& v) {
+    return bidirectional_iterator<const char*>(&v.cb);
+  }
+  constexpr bidirectional_iterator<const char*> end() const { return bidirectional_iterator<const char*>(&ce); }
+};
+static_assert( std::is_invocable_v<RangeREndT, FunctionBeginMemberEnd&>);
+static_assert( std::is_invocable_v<RangeREndT, FunctionBeginMemberEnd const&>);
+static_assert( std::is_invocable_v<RangeCREndT, FunctionBeginMemberEnd const&>);
+
+struct MemberBeginEndDifferentTypes {
+  bidirectional_iterator<int*> begin();
+  bidirectional_iterator<char*> end();
+};
+static_assert(!std::is_invocable_v<RangeREndT, MemberBeginEndDifferentTypes&>);
+static_assert(!std::is_invocable_v<RangeCREndT, MemberBeginEndDifferentTypes&>);
+
+struct FunctionBeginEndDifferentTypes {
+  friend bidirectional_iterator<int*> begin(FunctionBeginEndDifferentTypes&);
+  friend bidirectional_iterator<char*> end(FunctionBeginEndDifferentTypes&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, FunctionBeginEndDifferentTypes&>);
+static_assert(!std::is_invocable_v<RangeCREndT, FunctionBeginEndDifferentTypes&>);
+
+struct MemberBeginEndForwardIterators {
+  forward_iterator<int*> begin();
+  forward_iterator<int*> end();
+};
+static_assert(!std::is_invocable_v<RangeREndT, MemberBeginEndForwardIterators&>);
+static_assert(!std::is_invocable_v<RangeCREndT, MemberBeginEndForwardIterators&>);
+
+struct FunctionBeginEndForwardIterators {
+  friend forward_iterator<int*> begin(FunctionBeginEndForwardIterators&);
+  friend forward_iterator<int*> end(FunctionBeginEndForwardIterators&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, FunctionBeginEndForwardIterators&>);
+static_assert(!std::is_invocable_v<RangeCREndT, FunctionBeginEndForwardIterators&>);
+
+struct MemberBeginOnly {
+  bidirectional_iterator<int*> begin();
+};
+static_assert(!std::is_invocable_v<RangeREndT, MemberBeginOnly&>);
+static_assert(!std::is_invocable_v<RangeCREndT, MemberBeginOnly&>);
+
+struct FunctionBeginOnly {
+  friend bidirectional_iterator<int*> begin(FunctionBeginOnly&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, FunctionBeginOnly&>);
+static_assert(!std::is_invocable_v<RangeCREndT, FunctionBeginOnly&>);
+
+struct MemberEndOnly {
+  bidirectional_iterator<int*> end();
+};
+static_assert(!std::is_invocable_v<RangeREndT, MemberEndOnly&>);
+static_assert(!std::is_invocable_v<RangeCREndT, MemberEndOnly&>);
+
+struct FunctionEndOnly {
+  friend bidirectional_iterator<int*> end(FunctionEndOnly&);
+};
+static_assert(!std::is_invocable_v<RangeREndT, FunctionEndOnly&>);
+static_assert(!std::is_invocable_v<RangeCREndT, FunctionEndOnly&>);
+
+// Make sure there is no clash between the following cases:
+// - the case that handles classes defining member `rbegin` and `rend` functions;
+// - the case that handles classes defining `begin` and `end` functions returning reversible iterators.
+struct MemberBeginAndRBegin {
+  int* begin() const;
+  int* end() const;
+  int* rbegin() const;
+  int* rend() const;
+};
+static_assert( std::is_invocable_v<RangeREndT, MemberBeginAndRBegin&>);
+static_assert( std::is_invocable_v<RangeCREndT, MemberBeginAndRBegin&>);
+
+constexpr bool testBeginEnd() {
+  MemberBeginEnd a{};
+  const MemberBeginEnd aa{};
+  assert(std::ranges::rend(a).base().base() == &a.b);
+  assert(std::ranges::crend(a).base().base() == &a.cb);
+  assert(std::ranges::rend(aa).base().base() == &aa.cb);
+  assert(std::ranges::crend(aa).base().base() == &aa.cb);
+
+  FunctionBeginEnd b{};
+  const FunctionBeginEnd bb{};
+  assert(std::ranges::rend(b).base().base() == &b.b);
+  assert(std::ranges::crend(b).base().base() == &b.cb);
+  assert(std::ranges::rend(bb).base().base() == &bb.cb);
+  assert(std::ranges::crend(bb).base().base() == &bb.cb);
+
+  MemberBeginFunctionEnd c{};
+  const MemberBeginFunctionEnd cc{};
+  assert(std::ranges::rend(c).base().base() == &c.b);
+  assert(std::ranges::crend(c).base().base() == &c.cb);
+  assert(std::ranges::rend(cc).base().base() == &cc.cb);
+  assert(std::ranges::crend(cc).base().base() == &cc.cb);
+
+  FunctionBeginMemberEnd d{};
+  const FunctionBeginMemberEnd dd{};
+  assert(std::ranges::rend(d).base().base() == &d.b);
+  assert(std::ranges::crend(d).base().base() == &d.cb);
+  assert(std::ranges::rend(dd).base().base() == &dd.cb);
+  assert(std::ranges::crend(dd).base().base() == &dd.cb);
+
+  return true;
+}
+
+
+ASSERT_NOEXCEPT(std::ranges::rend(std::declval<int (&)[10]>()));
+ASSERT_NOEXCEPT(std::ranges::crend(std::declval<int (&)[10]>()));
+
+struct NoThrowMemberREnd {
+  ThrowingIterator<int> rbegin() const;
+  ThrowingIterator<int> rend() const noexcept; // auto(t.rend()) doesn't throw
+} ntmre;
+static_assert(noexcept(std::ranges::rend(ntmre)));
+static_assert(noexcept(std::ranges::crend(ntmre)));
+
+struct NoThrowADLREnd {
+  ThrowingIterator<int> rbegin() const;
+  friend ThrowingIterator<int> rend(NoThrowADLREnd&) noexcept;  // auto(rend(t)) doesn't throw
+  friend ThrowingIterator<int> rend(const NoThrowADLREnd&) noexcept;
+} ntare;
+static_assert(noexcept(std::ranges::rend(ntare)));
+static_assert(noexcept(std::ranges::crend(ntare)));
+
+struct NoThrowMemberREndReturnsRef {
+  ThrowingIterator<int> rbegin() const;
+  ThrowingIterator<int>& rend() const noexcept; // auto(t.rend()) may throw
+} ntmrerr;
+static_assert(!noexcept(std::ranges::rend(ntmrerr)));
+static_assert(!noexcept(std::ranges::crend(ntmrerr)));
+
+struct REndReturnsArrayRef {
+    auto rbegin() const noexcept -> int(&)[10];
+    auto rend() const noexcept -> int(&)[10];
+} rerar;
+static_assert(noexcept(std::ranges::rend(rerar)));
+static_assert(noexcept(std::ranges::crend(rerar)));
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeREndT, Holder<Incomplete>*>);
+static_assert(!std::is_invocable_v<RangeREndT, Holder<Incomplete>*&>);
+static_assert(!std::is_invocable_v<RangeCREndT, Holder<Incomplete>*>);
+static_assert(!std::is_invocable_v<RangeCREndT, Holder<Incomplete>*&>);
+
+int main(int, char**) {
+  static_assert(testReturnTypes());
+
+  testArray();
+  static_assert(testArray());
+
+  testREndMember();
+  static_assert(testREndMember());
+
+  testREndFunction();
+  static_assert(testREndFunction());
+
+  testBeginEnd();
+  static_assert(testBeginEnd());
+
+  return 0;
+}