[libcxx][ranges] adds `range` access CPOs

[cjdb]

Summary

• std::ranges::begin
• std::ranges::cbegin
• std::ranges::end
• std::ranges::cend
• std::ranges::iterator (required for end)

Implements parts of:

• P0896R4 The One Ranges Proposal`

Co-author: @zoecarver

Depends on D90999, D100160.

[cjdb]

fixes dependency in commit message (NFC)

[cjdb]

corrects and suppresses clang-format due to its inexperience with concepts

[cjdb]

updates commit message (NFC)

[• Quuxplusone]

libcxx/include/ranges

2–4

Please make the appropriate change to libcxx/utils/generate_header_inclusion_tests.py.
Also, this file needs a copyright header.

libcxx/include/type_traits

2816

This is unconditionally noexcept. I don't think you intended that?

libcxx/test/libcxx/ranges/range.access/access.h

9–10

Header guard doesn't match filename.

103–104

Throughout: please break lines to fit the review window. I suggest breaking after the last , (i.e., semantic linebreaks).

324–327

FWIW, rather than reopening namespace std in the tests, I'd prefer to see

template <>
inline constexpr bool
    std::ranges::enable_borrowed_range<unqualified_rvalue_range> = true;

libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp

25

Bikeshed: this seems much too easy to typo. I've been using namespace rg = std::ranges in my own slide code; anyone got thoughts?
Of course, I'm also not a huge fan of this test, since it has dependencies on so many containers. It would be better to do just like

#include <ranges>
#include <type_traits>
#include "test_iterators.h"
struct X {
    forward_iterator<int> begin();
    forward_iterator<int> end();
    forward_iterator<char> begin() const;
    forward_iterator<char> end() const;
};
static_assert(std::is_same_v<std::ranges::iterator_t<X>, forward_iterator<int>>);
static_assert(std::is_same_v<std::ranges::iterator_t<const X>, forward_iterator<char>>);
static_assert(std::is_same_v<std::ranges::iterator_t<double[10]>, double*>);

libcxx/test/support/test_macros.h

292

I don't like this macro at all; I'd much rather you just write out

assert(test());
static_assert(test());

if that's what the test is supposed to be testing.
However, if @ldionne asks you to keep it for some reason, then please at least make it
#define CONSTEXPR_ASSERT(...) assert((__VA_ARGS__)) in C++03 mode, and

#define CONSTEXPR_ASSERT(...) do { \
  static_assert((__VA_ARGS__), ""); \
  assert((__VA_ARGS__)); \
} while (0)

in C++11-and-later mode.

[cjdb]

re-adds missing underscore that was deleted in clang-format cleanup

[tcanens]

libcxx/include/__ranges/access.h

68

This needs to reject const rvalue arrays.

76

It'd be nice to avoid an extra move when begin returns a prvalue (as they almost always do).

121

Isn't extent_v<_Tp[_Np]> just _Np?

156

This is never going to be called since _Tp can't be deduced.

[cjdb]

addresses feedback from @Quuxplusone and @tcanens

[cjdb]

libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp

25

Bikeshed: this seems much too easy to typo. I've been using namespace rg = std::ranges in my own slide code; anyone got thoughts?

🤷 I'm happy to bikeshed on Discord (not in-review please).

Of course, I'm also not a huge fan of this test, since it has dependencies on so many containers. It would be better to do just like

Part of the point of this test is to ensure backwards compatibility with all of our containers. That was a design goal for ranges, and should be reflected here IMO.

libcxx/test/support/test_macros.h

292

I don't like this macro at all; I'd much rather you just write out

assert(test());
static_assert(test());

That's pretty error-prone. One might forget one of the asserts, both of which are critical.

#define CONSTEXPR_ASSERT(...) assert((__VA_ARGS__)) in C++03 mode, and

Done.

#define CONSTEXPR_ASSERT(...) do { \
 static_assert((__VA_ARGS__), ""); \
 assert((__VA_ARGS__)); \
} while (0)

in C++11-and-later mode.

I don't see why this change is necessary.

[cjdb]

libcxx/include/__ranges/access.h

68

See deleted overload below.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[Mordante]

I'll have a close look once it passes the build server. I expect pre-merge errors due to conflicts with D90999. Both modify add the <ranges> header.

libcxx/include/CMakeLists.txt

136

Please keep the list sorted. The recently added __memory/* are also sorted.

libcxx/include/__ranges/access.h

10

For consistency _LIBCPP_RANGES_ACCESS_H -> _LIBCPP___RANGES_ACCESS_H.

26

I would like to keep _LIBCPP_STD_VER > 17 to be consistent with <concepts>.

39

Shouldn't remove_cvref_t be remove_cv_t?

libcxx/include/ranges

3

Copy-paste "concepts".

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[zoecarver]

Not yet finished reviewing, but I've been accumulating comments here over the past few days and want to submit them before stuff moves around too much. I'll have more comments later when I do a proper review.

libcxx/include/__ranges/end.h

36 ↗

(On Diff #339091)

Nit: space.

73 ↗

(On Diff #339091)

This should be copied, right?

80 ↗

(On Diff #339091)

I haven't quite made it through all the macros/tests yet but can you please make sure there's a test for this where you declare a hidden friend, something like

namespace std { namespace ranges {

struct dummy {
  friend void begin() { }
};

}}

that would be an ODR violation, but isn't because of this inline namespace?

In other words, please make sure this fails to compile when the inline namespace is removed.

89 ↗

(On Diff #339091)

I will begrudgingly point out that these should have three underscores.

libcxx/include/ranges

11

Synopsis usually use a multiline comment.

libcxx/test/libcxx/ranges/range.access/access.h

16

Nit: consider just using structs for all of these.

103–104

Note: the review window is different for everyone.

libcxx/test/std/ranges/range.access/array_access.h

31

How about rvalue array types?

[cjdb]

rebases to activate CI

[tcanens]

The array-of-incomplete-element case is IFNDR. I think we really want that case to be a SFINAE-unfriendly hard error, since it's a recipe for disaster (ODR violations).

[cjdb]

In D100255#2713772, @tcanens wrote:

The array-of-incomplete-element case is IFNDR. I think we really want that case to be a SFINAE-unfriendly hard error, since it's a recipe for disaster (ODR violations).

Won't the deleted overloads take care of that?

[tcanens]

In D100255#2714675, @cjdb wrote:

In D100255#2713772, @tcanens wrote:

The array-of-incomplete-element case is IFNDR. I think we really want that case to be a SFINAE-unfriendly hard error, since it's a recipe for disaster (ODR violations).

Won't the deleted overloads take care of that?

Deleted is still SFINAE-friendly.

[cjdb]

• adds extra underscores to headers to make it _LIBCPP___RANGES_* (@zoecarver)
• makes lvalue arrays of incomplete types SFINAE-unfriendly (verification tests added) (@tcanens)
• removes _LIBCPP_NOEXCEPT_RETURN (@ldionne)
  • makes __decay_copy conditionally noexcept in C++20 mode
• adds conformance tests for all ranges for std::iterator_t
  • std::ranges::begin is implicitly tested by std::ranges::iterator_t
  • std::ranges::end is implicitly tested by std::ranges::sentinel_t, which is added in D
• adds test for ODR violation (@zoecarver)
• sorts headers in CMakeLists.txt (@Mordante)

libcxx/test/std/ranges/range.access/array_access.h

31

Line 29 takes care of this 🙂

libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp

25

Since no discussion occurred, I replaced stdr:: in places where it could be ambiguous with std::ranges. Places where it isn't ambiguous can remain as-is.

[cjdb]

• fixes Windows build failure
• parameterises test_range

[zoecarver]

libcxx/include/__ranges/begin.h

30 ↗

(On Diff #340311)

Nit: You keep opening and closing this namespace but everything in this file goes in it. Why not just open it at the beginning and leave it open?

36 ↗

(On Diff #340311)

Seems like it might be helpful to have this in a more general place, WDYT?

64 ↗

(On Diff #340311)

I'm confused, why can't we just do

static_assert(__is_complete<remove_cv_t<_Tp> >, "...");
return __t + 0;

?

libcxx/test/std/ranges/range.access/member_access.h

44

Nit: !std::is_...

libcxx/test/std/ranges/range.access/unqualified_lookup_access.h

23

Maybe make this and the other one noexcept(false) with a comment about why.

[zoecarver]

Okay, to be honest, I really do not like these tests.

I think we need to workshop the structure here because the current tests fall down in terms of readability and demonstrability. We can get to correctness and completeness later, but let's get the model right first.

Tests shouldn't have too much boilerplate, and in the test file itself, it should be clear what is being tested and how it's being tested. There should be enough context to figure out what's going on.

The current tests in ranges/range.access/* fail at this. There is a lot of boilerplate. We should try to be modest with the use of macros and only use them when they are unequivocally the best answer, and there isn't another clear way to do something. In these tests everything, including the main function, is hidden inside of a macro. This is not readable.

A good test would look like this:

struct a_clearly_named_type;
static_assert(!is_invocable_v<RangesBeginT, a_clearly_named_type>);

There are a few things here: first, it is clear what is being tested because of the context. The name CHECK_MEMBER_ACCESS tells me very little. However, the expression !is_invocable_v tells me that we shouldn't be able to call ranges::begin because of some constraint. Hopefully, the type a_clearly_named_type explains what constraint is being violated.

Second, it's easily verifiable. If I'm reading this test with the standard next to me, I can easily match the text in the standard to the static_assert and check it off mentally. It is much more difficult to do this when you have to follow the input into a macro full of boilerplate and distractions where the code is generated. My mind does not have a large enough cache for this to be feasible, sorry :P

It would be one thing if these macros were stress testing concepts, or ranges, or whatever. But they're not. They're being used for the tests that are supposed to demonstrate the API and its correctness.

The issues above are making it hard for me to verify correctness, but these tests are definitely not complete. For example, where are the tests for a type without any members? Or a member with the wrong return type? I think there are a few tests you need to add; luckily, I think these will be immediately obvious with a new test structure.

[cjdb]

In D100255#2717763, @zoecarver wrote:

Okay, to be honest, I really do not like these tests.

I think we need to workshop the structure here because the current tests fall down in terms of readability and demonstrability. We can get to correctness and completeness later, but let's get the model right first.

Tests shouldn't have too much boilerplate, and in the test file itself, it should be clear what is being tested and how it's being tested. There should be enough context to figure out what's going on.

The current tests in ranges/range.access/* fail at this. There is a lot of boilerplate. We should try to be modest with the use of macros and only use them when they are unequivocally the best answer, and there isn't another clear way to do something. In these tests everything, including the main function, is hidden inside of a macro. This is not readable.

A good test would look like this:

struct a_clearly_named_type;
static_assert(!is_invocable_v<RangesBeginT, a_clearly_named_type>);

There are a few things here: first, it is clear what is being tested because of the context. The name CHECK_MEMBER_ACCESS tells me very little. However, the expression !is_invocable_v tells me that we shouldn't be able to call ranges::begin because of some constraint. Hopefully, the type a_clearly_named_type explains what constraint is being violated.

Second, it's easily verifiable. If I'm reading this test with the standard next to me, I can easily match the text in the standard to the static_assert and check it off mentally. It is much more difficult to do this when you have to follow the input into a macro full of boilerplate and distractions where the code is generated. My mind does not have a large enough cache for this to be feasible, sorry :P

It would be one thing if these macros were stress testing concepts, or ranges, or whatever. But they're not. They're being used for the tests that are supposed to demonstrate the API and its correctness.

The issues above are making it hard for me to verify correctness, but these tests are definitely not complete. For example, where are the tests for a type without any members? Or a member with the wrong return type? I think there are a few tests you need to add; luckily, I think these will be immediately obvious with a new test structure.

I agree, will look into this.

libcxx/include/__ranges/begin.h

30 ↗

(On Diff #340311)

I think @ldionne wants stuff to be indented inside this namespace, and I don't want to do more than one indentation.

36 ↗

(On Diff #340311)

Where do you suggest?

64 ↗

(On Diff #340311)

__t + 0 yields a cryptic diagnostic (that could also be a red herring) when the condition is false.

[ldionne]

I also agree with Zoe on the point of testing, but it's been said before so no need for me to. I'm looking forward to the update!

libcxx/include/CMakeLists.txt

23–26

I have to admit this is one instance of a split that, IMO, doesn't add anything. I think it makes a lot more sense to group those into the same header since they are basically always used together (you pretty much always need end when you use begin and vice versa).

I'd throw that into something like __ranges/access.h.

libcxx/include/__ranges/begin.h

30 ↗

(On Diff #340311)

My general rule of thumb is to go for clarity - when I open a namespace and shove a lot of things in it, I tend not to indent everything, but I add a comment at the closing brace. When I open a namespace for just a few things, I generally indent them and skip the closing brace comment since we can easily see what the brace is related to from the indentation. So, no hard rule here, really just do what's most readable.

68 ↗

(On Diff #340311)

Typo: is SFINAE-unfriendly on arrays

Also, of an incomplete types should not be plural.

libcxx/include/__ranges/end.h

62 ↗

(On Diff #340311)

Same typos.

libcxx/include/ranges

20

Is it really relevant to mark those as being part of an unspecified inline namespace in the synopsis?

libcxx/test/libcxx/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

29 ↗

(On Diff #340311)

I'd suggest removing the file name here, it's just noise when we move stuff around.

[cjdb]

libcxx/include/ranges

20

🤷 Depends on how much we want our synopses to reflect the standard synopses?

[expnkx]

Hello. When are we going to have std::ranges::contiguous_range?

[ldionne]

In D100255#2718315, @expnkx wrote:

Hello. When are we going to have std::ranges::contiguous_range?

When it gets implemented. We're working towards that. I think Zoe was working on it this week.

Also, this is the wrong place to ask for this. This is the right forum for code reviews. Please take a look at our Discord channel for other questions.

[ldionne]

libcxx/include/ranges

20

Sure, I don't mind either way.

[ldionne]

libcxx/test/libcxx/ranges/range.access/access.h

135

I'm not seeing the point of testing those as libc++-only tests. Is it not possible to get equivalent coverage without reaching into the entrails of libc++?

We normally try to only create libc++-specific tests for libc++-specific behavior (like a vendor extension or some specific guarantee that we provide but isn't mandated by the spec).

libcxx/test/support/test_macros.h

292

Honestly I think defining a CONSTEXPR_ASSERT macro is much more error-prone than just spelling it out. I'm generally totally in favour of eliminating duplication, but not when that duplication is both minimal and helpful to see explicitly. I'd rather not add CONSTEXPR_ASSERT, I think it obfuscates things more than anything else.

[ldionne]

libcxx/include/__ranges/begin.h

88 ↗

(On Diff #340311)

What is the purpose of that overload?

[zoecarver]

libcxx/include/__ranges/begin.h

88 ↗

(On Diff #340311)

It's supposed to make the error message easier to read. I had it in an earlier version of ranges::size but decided to remove it after some discussion: https://reviews.llvm.org/D101079#inline-953328

Here's a gist I made for the difference in error messages for ranges::size: https://gist.github.com/zoecarver/594015f42664e3daa7ab7c3978027682

The ranges::begin errors may look different, though.

[cjdb]

• updates tests for begin and cbegin (tests for end and cend to come after initial feedback on begin)
• removes libc++ tests
• removes CONSTEXPR_ASSERT

[zoecarver]

libcxx/test/std/ranges/range.access/begin.h

39 ↗

(On Diff #341347)

nit: maybe use borrowed here to match everything else, but it's nonblocking.

71 ↗

(On Diff #341347)

I guess it doesn't hurt to have this but at what point are you going to have a const rvalue?

220 ↗

(On Diff #341347)

Do we really need a test for this? Could you even write an implementation that picked the wrong begin?

346 ↗

(On Diff #341347)

I should add a test like this for ranges::size :)

346 ↗

(On Diff #341347)

How about the reverse of this members_with_bad_lvalue_adl?

430 ↗

(On Diff #341347)

For future reference: I'm not sure we need rvalue and lvalue types when testing something like this. That logic has already been tested, so one test with a data member should be sufficient.

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

165 ↗

(On Diff #341347)

Copy paste error?

228 ↗

(On Diff #341347)

Why the extra parens?

229 ↗

(On Diff #341347)

Why is this commented out?

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

28 ↗

(On Diff #341347)

I think it would make more sense to call std::ranges::begin directly here. Certainly don't use __begin::__fn, especially if it's not in a libc++ test (which this probably shouldn't be anyway).

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

48 ↗

(On Diff #341347)

I'm generally fairly wary of tests like this where the expected value is computed. I think the best tests are the ones where the "desired result" or expected value are concrete/literal. It's easier to read and verify that way. Additionally, if there was a bug in the implementation (for example if we couldn't use as_const for some reason) it wouldn't be caught.

That begin said, I don't need you to change anything here, I just wanted to point it out so you could think about this going forward. The most important check here is the std::invocable<cbegin_t&, T> one, and that one isn't computed (at least not in the same way).

112 ↗

(On Diff #341347)

I would expect this to be false. It seems like all over this test rvalues with borrowing disabled are allowed when they shouldn't be.

165 ↗

(On Diff #341347)

Same as in the other file.

[zoecarver]

@cjdb the following should work (but doesn't):

static_assert(std::is_invocable_v<RangeBeginT, int (&)[]>);

[cjdb]

nice catch @zoecarver, fixed now

[cjdb]

adopts @zoecarver's simpler tests

[cjdb]

rebases to activate CI

[zoecarver]

A few nits but other than that this LGTM. Let's finally get this landed (as soon as Louis signs off on it)!

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

27 ↗

(On Diff #341728)

You can remove this now that incomplete arrays are tested elsewhere.

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

24 ↗

(On Diff #341728)

I still feel like this is a bit of an awkward way to test this.. why not call it in the body of the function?

libcxx/test/std/ranges/range.access/range.access.cbegin/incomplete.compile.verify copy.cpp

1 ↗

(On Diff #341728)

It looks like this file is duplicated. It's named "verify copy.cpp"

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

22 ↗

(On Diff #341728)

Why are we making this a reference type?

[cjdb]

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

28 ↗

(On Diff #341347)

Do you mean something like static_assert(requires { std::ranges::begin(std::declval<incomplete(&)[]>()) });?

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

22 ↗

(On Diff #341728)

std::ranges::end(x) is invoking std::ranges::__end::__fn::operator() as an lvalue, so we should be checking that, IMO.

[ldionne]

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

205 ↗

(On Diff #341728)

Glad to see this, I was going to request exactly it.

[zoecarver]

Let's land this!

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

28 ↗

(On Diff #341347)

No I mean you could do something like:

void test(incomplete(&arg)[]) {
  std::ranges::begin(arg);
}

Or

std::ranges::begin(std::declval<incomplete(&)[]>());

This is how someone is actually going to be using the function object when we expect to see the error.

Anyway, this isn't a big deal so either way is fine.

[cjdb]

Most of Zoe's comments have been applied just before merging with main.

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

28 ↗

(On Diff #341347)

Since this is a test for SFINAE friendliness, I don't think I can achieve that (I did try).

[zoecarver]

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp

28 ↗

(On Diff #341347)

If this is a test for SFINAE friendliness, then it is important that the above code I posted causes this to fail to compile. Luckily it appears that it does. I just tested this

std::ranges::begin(std::declval<Incomplete(&)[]>());

locally and it produced

atic_assert failed due to requirement '__complete' "`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."
        static_assert(__complete, "`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type.");
        ^             ~~~~~~~~~~
/Users/zoecarver/Developer/llvm-source/llvm-project/libcxx/test/std/ranges/range.access/range.access.begin/begin.pass.cpp:59:21: note: in instantiation of function template specialization 'std::ranges::__begin::__fn::operator()<Incomplete []>' requested here
  std::ranges::begin(std::declval<Incomplete(&)[]>());

libcxx/include/CMakeLists.txt

set(files
   __locale
   __memory/allocator_traits.h
   __memory/base.h
   __memory/pointer_traits.h
   __memory/utilities.h
   __mutex_base
   __node_handle
   __nullptr
   __split_buffer
   __sso_allocator
   __std_stream
   __string
   __threading_support
   __tree
   __tuple
   __undef_macros
   algorithm
   any
   array
   atomic
set(files
   new
   numbers
   numeric
   optional
   ostream
   queue
   random
   ratio
+  ranges
+  __ranges/access.h
   regex
   scoped_allocator
   semaphore
   set
   setjmp.h
   shared_mutex
   span
   sstream

libcxx/include/__ranges/access.h

+// -*- C++ -*-
+//===-------------------------- concepts ----------------------------------===//
+//
+// 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 <__config>
+#include <iterator>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+#define _LIBCPP_NOEXCEPT_RETURN(...)                                           \
+  noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
+
+// clang-format off
+namespace ranges {
+// FIXME: enable_borrowed_range is only present until D90999 is merged.
+template <class _Tp>
+inline constexpr bool enable_borrowed_range = false;
+
+template <class _Tp>
+concept __can_borrow =
+    is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp> >;
+
+template <class _Tp>
+concept __is_complete = requires { sizeof(_Tp); };
+
+// [range.access.begin]
+namespace __begin {
+template <class _Tp>
+concept __member_begin =
+  __can_borrow<_Tp> &&
+  requires(_Tp&& __t) {
+    { _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).begin()) } -> input_or_output_iterator;
+  };
+
+void begin(auto&) = delete;
+void begin(const auto&) = delete;
+
+template <class _Tp>
+concept __unqualified_begin =
+  !__member_begin<_Tp> &&
+  __can_borrow<_Tp> &&
+  _class_or_enum<_Tp> &&
+  requires(_Tp && __t) {
+    { _VSTD::__decay_copy(begin(_VSTD::forward<_Tp>(__t))) } -> input_or_output_iterator;
+  };
+
+struct __fn {
+  template <class _Tp, size_t _Np>
+  requires __is_complete<remove_all_extents_t<_Tp> >
+  [[nodiscard]] constexpr _Tp* operator()(_Tp (&__t)[_Np]) const noexcept {
+    return __t + 0;
+  }
+
+  template <class _Tp>
+  requires __member_begin<_Tp>
+  [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).begin())
+  )
+
+  template <class _Tp>
+  requires __unqualified_begin<_Tp>
+  [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    _VSTD::__decay_copy(begin(_VSTD::forward<_Tp>(__t)))
+  )
+};
+} // namespace __begin
+
+inline namespace __cpo {
+inline constexpr auto begin = __begin::__fn{};
+} // namespace __cpo
+
+// `iterator_t` is repeated in <__ranges/access.h> and <__ranges/concepts.h> for clarity's sake.
+template <class _Tp>
+using iterator_t = decltype(ranges::begin(declval<_Tp&>()));
+
+// [range.access.end]
+namespace __end {
+template <class _Tp>
+concept __member_end = __can_borrow<_Tp>&& requires(_Tp&& __t) {
+  typename iterator_t<_Tp>;
+  { _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).end()) } -> sentinel_for<iterator_t<_Tp> >;
+};
+
+void end(auto&) = delete;
+void end(const auto&) = delete;
+
+template <class _Tp>
+concept __unqualified_end =
+  !__member_end<_Tp> &&
+  __can_borrow<_Tp> &&
+  __class_or_enum<_Tp> &&
+  requires(_Tp && __t) {
+    typename iterator_t<_Tp>;
+    { _VSTD::__decay_copy(end(_VSTD::forward<_Tp>(__t))) } -> sentinel_for<iterator_t<_Tp> >;
+  };
+
+struct __fn {
+  template <class _Tp, size_t _Np>
+  requires __is_complete<remove_all_extents_t<_Tp> >
+  [[nodiscard]] constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept {
+    return __t + extent_v<_Tp[_Np]>;
+  }
+
+  template <class _Tp>
+  requires __member_end<_Tp>
+  [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).end())
+  )
+
+  template <class _Tp>
+  requires __unqualified_end<_Tp>
+  [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    _VSTD::__decay_copy(end(_VSTD::forward<_Tp>(__t)))
+  )
+};
+} // namespace __end
+
+inline namespace __cpo {
+inline constexpr auto end = __end::__fn{};
+} // namespace __cpo
+
+// [range.access.cbegin]
+namespace __cbegin {
+struct __fn {
+  template <class _Tp>
+  requires invocable<decltype(ranges::begin), _Tp const&>
+  [[nodiscard]] constexpr auto operator()(_Tp& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    ranges::begin(static_cast<_Tp const&>(__t))
+  )
+
+  template <class _Tp>
+  requires invocable<decltype(ranges::begin), _Tp const&&>
+  [[nodiscard]] constexpr auto operator()(remove_reference_t<_Tp>&& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    ranges::begin(static_cast<_Tp const&&>(__t))
+  )
+};
+} // namespace __cbegin
+
+inline namespace __cpo {
+inline constexpr auto cbegin = __cbegin::__fn{};
+} // namespace __cpo
+
+// [range.access.cend]
+namespace __cend {
+struct __fn {
+  template <class _Tp>
+  requires invocable<decltype(ranges::end), _Tp const&>
+  [[nodiscard]] constexpr auto operator()(_Tp& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    ranges::end(static_cast<_Tp const&>(__t))
+  )
+
+  template <class _Tp>
+  requires invocable<decltype(ranges::end), _Tp const&&>
+  [[nodiscard]] constexpr auto operator()(remove_reference_t<_Tp>&& __t) const
+  _LIBCPP_NOEXCEPT_RETURN(
+    ranges::end(static_cast<_Tp const&&>(__t))
+  )
+};
+} // namespace __cend
+
+inline namespace __cpo {
+inline constexpr auto cend = __cend::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+// clang-format on
+
+#undef _LIBCPP_NOEXCEPT_RETURN
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_RANGES_ACCESS_H

libcxx/include/module.modulemap

module queue {
     export initializer_list
     export *
   }
   module random {
     header "random"
     export initializer_list
     export *
   }
+  module ranges {
+    header "ranges"
+    export compare
+    export initializer_list
+    export iterator
+    export *
+  }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
     header "regex"
     export initializer_list
     export *

libcxx/include/ranges

+// #include <compare>              // see [compare.syn]
+// #include <initializer_list>     // see [initializer.list.syn]
+// #include <iterator>             // see [iterator.synopsis]
+//
+// namespace std::ranges {
+//   inline namespace unspecified {
+//     // [range.access], range access
+//     inline constexpr unspecified begin = unspecified;
+//     inline constexpr unspecified end = unspecified;
+//     inline constexpr unspecified cbegin = unspecified;
+//     inline constexpr unspecified cend = unspecified;
+//   }
+//
+//   // [range.range], ranges
+//   template<class T>
+//     using iterator_t = decltype(ranges::begin(declval<T&>()));
+// }
+
+#ifndef _LIBCPP_RANGES
+#define _LIBCPP_RANGES
+
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+#include <iterator>             // see [iterator.synopsis]
+
+#include <__ranges/access.h>
+
+#endif // _LIBCPP_RANGES

libcxx/include/type_traits

 forward(typename remove_reference<_Tp>::type&& __t) _NOEXCEPT
 {
     static_assert(!is_lvalue_reference<_Tp>::value,
                   "can not forward an rvalue as an lvalue");
     return static_cast<_Tp&&>(__t);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename decay<_Tp>::type
-__decay_copy(_Tp&& __t)
+__decay_copy(_Tp&& __t) _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__t)))
 {
     return _VSTD::forward<_Tp>(__t);
 }
 
 template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr>
 struct __member_pointer_traits_imp
 {
 };

libcxx/test/libcxx/ranges/range.access/access.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_LIBCXX_RANGES_RANGE_ACCESS_BAD_ACCESS_H
+#define LIBCXX_TEST_LIBCXX_RANGES_RANGE_ACCESS_BAD_ACCESS_H
+
+#include <ranges>
+#include <vector>
+
+class bad_lvalue_range_unqualified {
+public:
+  int begin(bad_lvalue_range_unqualified&);
+  int begin(bad_lvalue_range_unqualified const&);
+  int end(bad_lvalue_range_unqualified&);
+  int end(bad_lvalue_range_unqualified const&);
+};
+
+class bad_lvalue_range_preferred {
+public:
+  int begin();
+  int begin() const;
+  int end();
+  int end() const;
+
+  int begin(bad_lvalue_range_preferred&);
+  int begin(bad_lvalue_range_preferred const&);
+  int end(bad_lvalue_range_preferred&);
+  int end(bad_lvalue_range_preferred const&);
+};
+
+class bad_lvalue_range_private_members {
+public:
+  friend int begin(bad_lvalue_range_private_members&);
+  friend int begin(bad_lvalue_range_private_members const&);
+  friend int end(bad_lvalue_range_private_members&);
+  friend int end(bad_lvalue_range_private_members const&);
+
+private:
+  std::vector<int>::iterator begin();
+  std::vector<int>::const_iterator begin() const;
+  std::vector<int>::iterator end();
+  std::vector<int>::const_iterator end() const;
+};
+
+class rvalue_range_members_bad_return {
+public:
+  int begin() &&;
+  int begin() const&&;
+  int end() &&;
+  int end() const&&;
+};
+
+// An otherwise okay "range", except that it isn't borrowable, and thus can't be accessed as an
+// rvalue
+class rvalue_range_members_not_borrowable {
+public:
+  std::vector<int>::iterator begin() &&;
+  std::vector<int>::const_iterator begin() const&&;
+  std::vector<int>::iterator end() &&;
+  std::vector<int>::const_iterator end() const&&;
+};
+
+class rvalue_range_unqualified_bad_return {
+public:
+  friend int begin(rvalue_range_unqualified_bad_return&&);
+  friend int begin(rvalue_range_unqualified_bad_return const&&);
+  friend int end(rvalue_range_unqualified_bad_return&&);
+  friend int end(rvalue_range_unqualified_bad_return const&&);
+};
+
+class rvalue_range_preferred_bad_return {
+public:
+  int begin();
+  int begin() const;
+  int end();
+  int end() const;
+
+  friend int begin(rvalue_range_preferred_bad_return&&);
+  friend int begin(rvalue_range_preferred_bad_return const&&);
+  friend int end(rvalue_range_preferred_bad_return&&);
+  friend int end(rvalue_range_preferred_bad_return const&&);
+};
+
+class rvalue_range_private_members_bad_return {
+public:
+  friend int begin(rvalue_range_private_members_bad_return&&);
+  friend int begin(rvalue_range_private_members_bad_return const&&);
+  friend int end(rvalue_range_private_members_bad_return&&);
+  friend int end(rvalue_range_private_members_bad_return const&&);
+
+private:
+  std::vector<int>::iterator begin();
+  std::vector<int>::const_iterator begin() const;
+  std::vector<int>::iterator end();
+  std::vector<int>::const_iterator end() const;
+};
+
+// An otherwise okay "range", except that it isn't borrowable, and thus can't be accessed as an
+// rvalue
+class rvalue_range_unqualified_not_borrowable {
+public:
+  friend std::vector<int>::iterator
+  begin(rvalue_range_unqualified_not_borrowable&&);
+  friend std::vector<int>::const_iterator
+  begin(rvalue_range_unqualified_not_borrowable const&&);
+  friend std::vector<int>::iterator
+  end(rvalue_range_unqualified_not_borrowable&&);
+  friend std::vector<int>::const_iterator
+  end(rvalue_range_unqualified_not_borrowable const&&);
+};
+
+// An otherwise okay "range", except that it isn't borrowable, and thus can't be accessed as an
+// rvalue
+class rvalue_range_preferred_not_borrowable {
+public:
+  std::vector<int>::iterator begin() &&;
+  std::vector<int>::const_iterator begin() const&&;
+  std::vector<int>::iterator end() &&;
+  std::vector<int>::const_iterator end() const&&;
+
+  friend std::vector<int>::iterator
+  begin(rvalue_range_preferred_not_borrowable&&);
+  friend std::vector<int>::const_iterator
+  begin(rvalue_range_preferred_not_borrowable const&&);
+  friend std::vector<int>::iterator
+  end(rvalue_range_preferred_not_borrowable&&);
+  friend std::vector<int>::const_iterator
+  end(rvalue_range_preferred_not_borrowable const&&);
+};
+
+// An otherwise okay "range", except that it isn't borrowable, and thus can't be accessed as an
+// rvalue
+class rvalue_range_private_members_not_borrowable {
+public:
+  friend std::vector<int>::iterator
+  begin(rvalue_range_private_members_not_borrowable&&);
+  friend std::vector<int>::const_iterator
+  begin(rvalue_range_private_members_not_borrowable const&&);
+  friend std::vector<int>::iterator
+  end(rvalue_range_private_members_not_borrowable&&);
+  friend std::vector<int>::const_iterator
+  end(rvalue_range_private_members_not_borrowable const&&);
+
+private:
+  std::vector<int>::iterator begin();
+  std::vector<int>::const_iterator begin() const;
+  std::vector<int>::iterator end();
+  std::vector<int>::const_iterator end() const;
+};
+
+#define CHECK_BAD_ACCESS(cpo)                                                  \
+  template <class T>                                                           \
+  [[nodiscard]] constexpr bool faulty_##cpo() {                                \
+    static_assert(!std::ranges::__##cpo::__member_##cpo<T&>);                  \
+    static_assert(!std::ranges::__##cpo::__member_##cpo<T const&>);            \
+    static_assert(!std::ranges::__##cpo::__member_##cpo<T&&>);                 \
+    static_assert(!std::ranges::__##cpo::__member_##cpo<T const&&>);           \
+                                                                               \
+    static_assert(!std::ranges::__##cpo::__unqualified_##cpo<T&>);             \
+    static_assert(!std::ranges::__##cpo::__unqualified_##cpo<T const&>);       \
+    static_assert(!std::ranges::__##cpo::__unqualified_##cpo<T&&>);            \
+    static_assert(!std::ranges::__##cpo::__unqualified_##cpo<T const&&>);      \
+                                                                               \
+    static_assert(!std::invocable<decltype(std::ranges::cpo), T&>);            \
+    static_assert(!std::invocable<decltype(std::ranges::cpo), T const&>);      \
+    static_assert(!std::invocable<decltype(std::ranges::cpo), T>);             \
+    static_assert(!std::invocable<decltype(std::ranges::cpo), T const>);       \
+    return true;                                                               \
+  }                                                                            \
+                                                                               \
+  static_assert(faulty_##cpo<bad_lvalue_range_unqualified>());                 \
+  static_assert(faulty_##cpo<bad_lvalue_range_preferred>());                   \
+  static_assert(faulty_##cpo<bad_lvalue_range_private_members>());             \
+  static_assert(faulty_##cpo<rvalue_range_members_bad_return>());              \
+  static_assert(faulty_##cpo<rvalue_range_unqualified_bad_return>());          \
+  static_assert(faulty_##cpo<rvalue_range_preferred_bad_return>());            \
+  static_assert(faulty_##cpo<rvalue_range_private_members_bad_return>());      \
+  static_assert(faulty_##cpo<rvalue_range_unqualified_not_borrowable>());      \
+  static_assert(faulty_##cpo<rvalue_range_preferred_not_borrowable>());        \
+  static_assert(faulty_##cpo<rvalue_range_private_members_not_borrowable>())
+
+struct sentinel {
+  bool operator==(std::vector<int>::iterator) const;
+};
+
+struct lvalue_range_with_members {
+  std::vector<int>::iterator begin() &;
+  std::vector<int>::iterator begin() const&;
+  sentinel end() &;
+  sentinel end() const&;
+};
+
+struct lvalue_range_with_members_and_unqualified_friends
+    : lvalue_range_with_members {
+  friend std::vector<int>::iterator
+  begin(lvalue_range_with_members_and_unqualified_friends& x);
+  friend std::vector<int>::iterator
+  begin(lvalue_range_with_members_and_unqualified_friends const& x);
+  friend sentinel end(lvalue_range_with_members_and_unqualified_friends& x);
+  friend sentinel
+  end(lvalue_range_with_members_and_unqualified_friends const& x);
+};
+
+struct rvalue_range_with_members {
+  std::vector<int>::iterator begin();
+  std::vector<int>::iterator begin() const;
+  sentinel end();
+  sentinel end() const;
+};
+
+namespace std::ranges {
+template <>
+inline constexpr bool enable_borrowed_range<rvalue_range_with_members> = true;
+} // namespace std::ranges
+
+struct rvalue_range_with_members_and_unqualified_friends
+    : rvalue_range_with_members {
+  friend std::vector<int>::iterator
+  begin(rvalue_range_with_members_and_unqualified_friends&& x);
+  friend std::vector<int>::iterator
+  begin(rvalue_range_with_members_and_unqualified_friends const&& x);
+  friend sentinel end(rvalue_range_with_members_and_unqualified_friends&& x);
+  friend sentinel
+  end(rvalue_range_with_members_and_unqualified_friends const&& x);
+};
+
+namespace std::ranges {
+template <>
+inline constexpr bool
+    enable_borrowed_range<rvalue_range_with_members_and_unqualified_friends> =
+        true;
+} // namespace std::ranges
+
+#define CHECK_MEMBER_CPO(cpo)                                                  \
+  static_assert(                                                               \
+      std::ranges::__##cpo::__member_##cpo<lvalue_range_with_members&>);       \
+  static_assert(                                                               \
+      std::ranges::__##cpo::__member_##cpo<lvalue_range_with_members const&>); \
+  static_assert(std::ranges::__##cpo::__member_##cpo<                          \
+                lvalue_range_with_members_and_unqualified_friends&>);          \
+  static_assert(std::ranges::__##cpo::__member_##cpo<                          \
+                lvalue_range_with_members_and_unqualified_friends const&>);    \
+  static_assert(                                                               \
+      !std::ranges::__##cpo::__member_##cpo<lvalue_range_with_members&&>);     \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                lvalue_range_with_members const&&>);                           \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                lvalue_range_with_members_and_unqualified_friends&&>);         \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                lvalue_range_with_members_and_unqualified_friends const&&>);   \
+                                                                               \
+  static_assert(                                                               \
+      std::ranges::__##cpo::__member_##cpo<rvalue_range_with_members&>);       \
+  static_assert(                                                               \
+      std::ranges::__##cpo::__member_##cpo<rvalue_range_with_members const&>); \
+  static_assert(std::ranges::__##cpo::__member_##cpo<                          \
+                rvalue_range_with_members_and_unqualified_friends&>);          \
+  static_assert(std::ranges::__##cpo::__member_##cpo<                          \
+                rvalue_range_with_members_and_unqualified_friends const&>);    \
+  static_assert(                                                               \
+      std::ranges::__##cpo::__member_##cpo<rvalue_range_with_members&&>);      \
+  static_assert(std::ranges::__##cpo::__member_##cpo<                          \
+                rvalue_range_with_members const&&>);                           \
+  static_assert(std::ranges::__##cpo::__member_##cpo<                          \
+                rvalue_range_with_members_and_unqualified_friends&&>);         \
+  static_assert(std::ranges::__##cpo::__member_##cpo<                          \
+                rvalue_range_with_members_and_unqualified_friends const&&>)
+
+struct unqualified_lvalue_range {
+  friend std::vector<int>::iterator begin(unqualified_lvalue_range& x);
+  friend std::vector<int>::iterator begin(unqualified_lvalue_range const& x);
+  friend sentinel end(unqualified_lvalue_range& x);
+  friend sentinel end(unqualified_lvalue_range const& x);
+};
+
+struct unqualified_lvalue_range_preferred {
+  int begin();
+  int begin() const;
+  int end();
+  int end() const;
+
+  friend std::vector<int>::iterator
+  begin(unqualified_lvalue_range_preferred& x);
+  friend std::vector<int>::iterator
+  begin(unqualified_lvalue_range_preferred const& x);
+  friend sentinel end(unqualified_lvalue_range_preferred& x);
+  friend sentinel end(unqualified_lvalue_range_preferred const& x);
+};
+
+class unqualified_lvalue_range_private_members {
+public:
+  friend std::vector<int>::iterator
+  begin(unqualified_lvalue_range_private_members& x);
+  friend std::vector<int>::iterator
+  begin(unqualified_lvalue_range_private_members const& x);
+  friend sentinel end(unqualified_lvalue_range_private_members& x);
+  friend sentinel end(unqualified_lvalue_range_private_members const& x);
+
+private:
+  std::vector<int>::iterator begin() noexcept;
+  std::vector<int>::iterator begin() const;
+  sentinel end();
+  sentinel end() const;
+};
+
+class unqualified_rvalue_range {
+public:
+  friend std::vector<int>::iterator begin(unqualified_rvalue_range& x);
+  friend std::vector<int>::iterator begin(unqualified_rvalue_range const& x);
+  friend sentinel end(unqualified_rvalue_range& x);
+  friend sentinel end(unqualified_rvalue_range const& x);
+
+  friend std::vector<int>::iterator begin(unqualified_rvalue_range&& x);
+  friend std::vector<int>::iterator begin(unqualified_rvalue_range const&& x);
+  friend sentinel end(unqualified_rvalue_range&& x);
+  friend sentinel end(unqualified_rvalue_range const&& x);
+};
+
+namespace std::ranges {
+template <>
+inline constexpr bool enable_borrowed_range<unqualified_rvalue_range> = true;
+} // namespace std::ranges
+
+class unqualified_rvalue_range_preferred {
+public:
+  int begin();
+  int begin() const;
+  int end();
+  int end() const;
+
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_preferred& x);
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_preferred const& x);
+  friend sentinel end(unqualified_rvalue_range_preferred& x);
+  friend sentinel end(unqualified_rvalue_range_preferred const& x);
+
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_preferred&& x);
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_preferred const&& x);
+  friend sentinel end(unqualified_rvalue_range_preferred&& x);
+  friend sentinel end(unqualified_rvalue_range_preferred const&& x);
+};
+
+namespace std::ranges {
+template <>
+inline constexpr bool
+    enable_borrowed_range<unqualified_rvalue_range_preferred> = true;
+} // namespace std::ranges
+
+class unqualified_rvalue_range_private_members {
+public:
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_private_members& x);
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_private_members const& x);
+  friend sentinel end(unqualified_rvalue_range_private_members& x);
+  friend sentinel end(unqualified_rvalue_range_private_members const& x);
+
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_private_members&& x);
+  friend std::vector<int>::iterator
+  begin(unqualified_rvalue_range_private_members const&& x);
+  friend sentinel end(unqualified_rvalue_range_private_members&& x);
+  friend sentinel end(unqualified_rvalue_range_private_members const&& x);
+
+private:
+  std::vector<int>::iterator begin() noexcept;
+  std::vector<int>::iterator begin() const;
+  sentinel end() noexcept;
+  sentinel end() const;
+};
+
+namespace std::ranges {
+template <>
+inline constexpr bool
+    enable_borrowed_range<unqualified_rvalue_range_private_members> = true;
+} // namespace std::ranges
+
+#define CHECK_UNQUALIFIED_CPO(cpo)                                             \
+  static_assert(                                                               \
+      !std::ranges::__##cpo::__member_##cpo<unqualified_lvalue_range&> &&      \
+      std::ranges::__##cpo::__unqualified_##cpo<unqualified_lvalue_range&>);   \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_lvalue_range const&> &&                        \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_lvalue_range const&>);                         \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_lvalue_range_preferred&> &&                    \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_lvalue_range_preferred&>);                     \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_lvalue_range_preferred const&> &&              \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_lvalue_range_preferred const&>);               \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_lvalue_range_private_members&> &&              \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_lvalue_range_private_members&>);               \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_lvalue_range_private_members const&> &&        \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_lvalue_range_private_members const&>);         \
+                                                                               \
+  static_assert(                                                               \
+      !std::ranges::__##cpo::__unqualified_##cpo<unqualified_lvalue_range&&>); \
+  static_assert(!std::ranges::__##cpo::__unqualified_##cpo<                    \
+                unqualified_lvalue_range const&&>);                            \
+  static_assert(!std::ranges::__##cpo::__unqualified_##cpo<                    \
+                unqualified_lvalue_range_preferred&&>);                        \
+  static_assert(!std::ranges::__##cpo::__unqualified_##cpo<                    \
+                unqualified_lvalue_range_preferred const&&>);                  \
+  static_assert(!std::ranges::__##cpo::__unqualified_##cpo<                    \
+                unqualified_lvalue_range_private_members&&>);                  \
+  static_assert(!std::ranges::__##cpo::__unqualified_##cpo<                    \
+                unqualified_lvalue_range_private_members const&&>);            \
+                                                                               \
+  static_assert(                                                               \
+      !std::ranges::__##cpo::__member_##cpo<unqualified_rvalue_range&> &&      \
+      std::ranges::__##cpo::__unqualified_##cpo<unqualified_rvalue_range&>);   \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range const&> &&                        \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range const&>);                         \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_preferred&> &&                    \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_preferred&>);                     \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_preferred const&> &&              \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_preferred const&>);               \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_private_members&> &&              \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_private_members&>);               \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_private_members const&> &&        \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_private_members const&>);         \
+  static_assert(                                                               \
+      !std::ranges::__##cpo::__member_##cpo<unqualified_rvalue_range&&> &&     \
+      std::ranges::__##cpo::__unqualified_##cpo<unqualified_rvalue_range&&>);  \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range const&&> &&                       \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range const&&>);                        \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_preferred&&> &&                   \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_preferred&&>);                    \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_preferred const&&> &&             \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_preferred const&&>);              \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_private_members&&> &&             \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_private_members&&>);              \
+  static_assert(!std::ranges::__##cpo::__member_##cpo<                         \
+                    unqualified_rvalue_range_private_members const&&> &&       \
+                std::ranges::__##cpo::__unqualified_##cpo<                     \
+                    unqualified_rvalue_range_private_members const&&>)
+
+#endif // LIBCXX_TEST_LIBCXX_RANGES_RANGE_ACCESS_BAD_ACCESS_H

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// unspecified begin;
+#include <ranges>
+
+#include "../access.h"
+
+CHECK_BAD_ACCESS(begin);
+CHECK_MEMBER_CPO(begin);
+CHECK_UNQUALIFIED_CPO(begin);

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// unspecified end;
+#include <ranges>
+
+#include "../access.h"
+
+CHECK_BAD_ACCESS(end);
+CHECK_MEMBER_CPO(end);
+CHECK_UNQUALIFIED_CPO(end);

libcxx/test/std/ranges/range.access/array_access.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_ARRAY_ACCESS_H
+#define LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_ARRAY_ACCESS_H
+
+#include <ranges>
+
+#include <cassert>
+
+#include "test_macros.h"
+
+class dummy {
+public:
+  [[nodiscard]] constexpr int* begin() noexcept { return &second_; }
+
+  [[nodiscard]] constexpr int end() noexcept { return first_; }
+
+private:
+  int first_ = 0;
+  int second_ = 54;
+};
+
+#define CHECK_ARRAY_ACCESS(cpo)                                                \
+  static_assert(!std::invocable<decltype(std::ranges::cpo), double[321]>);     \
+  static_assert(!std::invocable<decltype(std::ranges::cpo), long(&)[]>);       \
+                                                                               \
+  template <typename T, std::size_t size>                                      \
+  [[nodiscard]] constexpr bool check_lvalue_array() {                          \
+    static_assert(std::invocable<decltype(std::ranges::cpo), T(&)[size]>);     \
+    static_assert(                                                             \
+        std::is_nothrow_invocable_v<decltype(std::ranges::cpo), T(&)[size]>);  \
+                                                                               \
+    T array[size]{};                                                           \
+    return std::ranges::cpo(array) == std::cpo(array);                         \
+  }                                                                            \
+                                                                               \
+  int main(int, char**) {                                                      \
+    CONSTEXPR_ASSERT(check_lvalue_array<int, 30>());                           \
+    CONSTEXPR_ASSERT(check_lvalue_array<double, 43>());                        \
+    CONSTEXPR_ASSERT(check_lvalue_array<dummy, 210>());                        \
+    return 0;                                                                  \
+  }
+
+#endif // LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_ARRAY_ACCESS_H

libcxx/test/std/ranges/range.access/member_access.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_MEMBER_ACCESS_H
+#define LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_MEMBER_ACCESS_H
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <deque>
+#include <forward_list>
+#include <iterator>
+#include <list>
+#include <map>
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "test_macros.h"
+
+#define RESULT_IS_ITERATOR std::input_or_output_iterator<result_type>
+#define RESULT_IS_SENTINEL                                                     \
+  std::sentinel_for<result_type, std::ranges::iterator_t<R> >
+#define RESULT_IS_POINTER std::is_pointer_v<result_type>
+
+// `cpo` can be any customisation point object in [range.access].
+// `base_cpo` can't be a CPO defined in terms of another CPO (e.g. cbegin) and it must be the "base"
+// of `cpo` if the parameters are different.
+// E.g. CHECK_MEMBER_ACCESS(begin, begin, RESULT_IS_ITERATOR)  // okay
+// E.g. CHECK_MEMBER_ACCESS(cdata, data, RESULT_IS_POINTER)   // okay: `cdata` is implemented in terms of `data`
+// E.g. CHECK_MEMBER_ACCESS(end, cend, RESULT_IS_SENTINEL)     // invalid: `end` isn't implemented in terms of `cend`
+// E.g. CHECK_MEMBER_ACCESS(rbegin, begin, RESULT_IS_REVERSE_ITERATOR) // invalid: `rbegin` isn't related to `begin`
+#define CHECK_MEMBER_ACCESS(cpo, base_cpo, check_result_type)                  \
+  static_assert(                                                               \
+      std::invocable<decltype(std::ranges::base_cpo), std::array<int, 100>&>); \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::map<int, double>&>);                       \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::map<int, double> const&>);                 \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::multimap<int, double>&>);                  \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::multimap<int, double> const&>);            \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::multiset<std::array<int, 1> >&>);          \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::multiset<std::array<int, 1> > const&>);    \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::set<std::array<int, 1> >&>);               \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::set<std::array<int, 1> > const&>);         \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_map<int, int>&>);                \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_map<int, int> const&>);          \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_multimap<int, int>&>);           \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_multimap<int, int> const&>);     \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_set<float>&>);                   \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_set<float> const&>);             \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_multiset<float>&>);              \
+  static_assert(std::invocable<decltype(std::ranges::base_cpo),                \
+                               std::unordered_multiset<float> const&>);        \
+                                                                               \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::map<int, double>&&>);                     \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::multimap<int, double>&&>);                \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::multiset<std::array<int, 1> >&&>);        \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::set<std::array<int, 1> >&&>);             \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::unordered_map<int, int>&&>);              \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::unordered_multimap<int, int>&&>);         \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::unordered_set<float>&&>);                 \
+  static_assert(!std::invocable<decltype(std::ranges::base_cpo),               \
+                                std::unordered_multiset<float>&&>);            \
+                                                                               \
+  template <class R>                                                           \
+  constexpr bool member_##cpo() {                                              \
+    using result_type = std::invoke_result_t<decltype(std::ranges::cpo), R&>;  \
+    static_assert(check_result_type);                                          \
+    static_assert(noexcept(std::ranges::cpo(std::declval<R&>())) ==            \
+                  noexcept(std::declval<R&>().base_cpo()));                    \
+                                                                               \
+    if (not std::is_constant_evaluated()) {                                    \
+      auto r = R(100, typename std::remove_cvref_t<R>::value_type());          \
+      assert(std::ranges::cpo(r) == r.base_cpo());                             \
+    }                                                                          \
+    return true;                                                               \
+  }                                                                            \
+                                                                               \
+  int main(int, char**) {                                                      \
+    member_##cpo<std::deque<double (*)()> >();                                 \
+    member_##cpo<std::deque<double (*)()> const>();                            \
+    member_##cpo<std::forward_list<int> >();                                   \
+    member_##cpo<std::forward_list<int> const>();                              \
+    member_##cpo<std::list<std::vector<int> > >();                             \
+    member_##cpo<std::list<std::vector<int> > const>();                        \
+    CONSTEXPR_ASSERT(member_##cpo<std::vector<std::set<int> > >());            \
+    CONSTEXPR_ASSERT(member_##cpo<std::vector<std::set<int> > const>());       \
+    return 0;                                                                  \
+  }
+
+#endif // LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_MEMBER_ACCESS_H

libcxx/test/std/ranges/range.access/range.access.begin/array_access.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: gcc-10
+
+// unspecified begin;
+#include <ranges>
+
+#include "../array_access.h"
+
+CHECK_ARRAY_ACCESS(begin);

libcxx/test/std/ranges/range.access/range.access.begin/member_access.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: gcc-10
+
+// unspecified begin;
+#include "../member_access.h"
+
+CHECK_MEMBER_ACCESS(begin, begin, RESULT_IS_ITERATOR)

libcxx/test/std/ranges/range.access/range.access.begin/unqualified_lookup.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: gcc-10
+
+// unspecified begin;
+#include <ranges>
+
+#include "../unqualified_lookup_access.h"
+
+static_assert(
+    !noexcept(std::ranges::begin(std::declval<unqualified_lookup_access&>())));
+static_assert(noexcept(
+    std::ranges::begin(std::declval<unqualified_lookup_access const&>())));
+CHECK_UNQUALIFIED_LOOKUP_ACCESS(begin, begin)

libcxx/test/std/ranges/range.access/range.access.cbegin/array_access.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: gcc-10
+
+// unspecified cbegin;
+#include <ranges>
+
+#include "../array_access.h"
+
+CHECK_ARRAY_ACCESS(cbegin);

libcxx/test/std/ranges/range.access/range.access.cbegin/member_access.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: gcc-10
+
+// unspecified cbegin;
+#include "../member_access.h"
+
+CHECK_MEMBER_ACCESS(cbegin, begin, RESULT_IS_ITERATOR)

libcxx/test/std/ranges/range.access/range.access.cbegin/unqualified_lookup.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: gcc-10
+
+// unspecified cbegin;
+#include <ranges>
+
+#include "../unqualified_lookup_access.h"
+
+static_assert(
+    noexcept(std::ranges::cbegin(std::declval<unqualified_lookup_access&>())));
+static_assert(noexcept(
+    std::ranges::cbegin(std::declval<unqualified_lookup_access const&>())));
+CHECK_UNQUALIFIED_LOOKUP_ACCESS(cbegin, begin)

libcxx/test/std/ranges/range.access/range.access.cend/array_access.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: gcc-10
+
+// unspecified cend;
+#include <ranges>
+
+#include "../array_access.h"
+
+CHECK_ARRAY_ACCESS(cend);

libcxx/test/std/ranges/range.access/range.access.cend/member_access.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: gcc-10
+
+// unspecified cend;
+#include "../member_access.h"
+
+CHECK_MEMBER_ACCESS(cend, end, RESULT_IS_SENTINEL)

libcxx/test/std/ranges/range.access/range.access.cend/unqualified_lookup.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: gcc-10
+
+// unspecified cend;
+#include <ranges>
+
+#include "../unqualified_lookup_access.h"
+
+static_assert(
+    noexcept(std::ranges::cend(std::declval<unqualified_lookup_access&>())));
+static_assert(noexcept(
+    std::ranges::cend(std::declval<unqualified_lookup_access const&>())));
+CHECK_UNQUALIFIED_LOOKUP_ACCESS(cend, end)

libcxx/test/std/ranges/range.access/range.access.end/array_access.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: gcc-10
+
+// unspecified end;
+#include <ranges>
+
+#include "../array_access.h"
+
+CHECK_ARRAY_ACCESS(end);

libcxx/test/std/ranges/range.access/range.access.end/member_access.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: gcc-10
+
+// unspecified end;
+#include "../member_access.h"
+
+CHECK_MEMBER_ACCESS(end, end, RESULT_IS_SENTINEL)

libcxx/test/std/ranges/range.access/range.access.end/unqualified_lookup.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: gcc-10
+
+// unspecified end;
+#include <ranges>
+
+#include "../unqualified_lookup_access.h"
+
+static_assert(
+    !noexcept(std::ranges::end(std::declval<unqualified_lookup_access&>())));
+static_assert(noexcept(
+    std::ranges::end(std::declval<unqualified_lookup_access const&>())));
+CHECK_UNQUALIFIED_LOOKUP_ACCESS(end, end)

libcxx/test/std/ranges/range.access/unqualified_lookup_access.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_UNQUALIFIED_LOOKUP_ACCESS_H
+#define LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_UNQUALIFIED_LOOKUP_ACCESS_H
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <utility>
+
+#include "test_macros.h"
+
+struct unqualified_lookup_access {
+  std::array<int, 10> data;
+
+  [[nodiscard]] constexpr friend auto begin(unqualified_lookup_access& x) {
+    return x.data.begin();
+  }
+
+  [[nodiscard]] constexpr friend auto
+  begin(unqualified_lookup_access const& x) noexcept {
+    return x.data.begin();
+  }
+
+  [[nodiscard]] constexpr friend auto end(unqualified_lookup_access& x) {
+    return x.data.end();
+  }
+
+  [[nodiscard]] constexpr friend auto
+  end(unqualified_lookup_access const& x) noexcept {
+    return x.data.end();
+  }
+};
+
+#define CHECK_UNQUALIFIED_LOOKUP_ACCESS(cpo, base_cpo)                         \
+  [[nodiscard]] constexpr bool check_unqualified_lookup() {                    \
+    auto r1 = unqualified_lookup_access();                                     \
+    assert(std::ranges::cpo(r1) == r1.data.base_cpo());                        \
+    assert(std::ranges::cpo(r1) == std::as_const(r1.data).base_cpo());         \
+    auto r2 = unqualified_lookup_access();                                     \
+    assert(std::ranges::cpo(r1) != std::ranges::cpo(r2));                      \
+    assert(std::ranges::cpo(std::as_const(r1)) !=                              \
+           std::ranges::cpo(std::as_const(r2)));                               \
+    return true;                                                               \
+  }                                                                            \
+                                                                               \
+  int main(int, char**) {                                                      \
+    CONSTEXPR_ASSERT(check_unqualified_lookup());                              \
+    return 0;                                                                  \
+  }
+
+#endif // #ifndef LIBCXX_TEST_STD_RANGES_RANGE_ACCESS_UNQUALIFIED_LOOKUP_ACCESS_H

libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class T>
+// using iterator_t = decltype(ranges::begin(declval<T&>()));
+
+#include <ranges>
+
+#include <concepts>
+#include <forward_list>
+#include <list>
+#include <deque>
+#include <vector>
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<std::forward_list<int> >,
+                           std::forward_list<int>::iterator>);
+static_assert(std::same_as<stdr::iterator_t<std::forward_list<int> const>,
+                           std::forward_list<int>::const_iterator>);
+
+static_assert(std::same_as<stdr::iterator_t<std::deque<int> >,
+                           std::deque<int>::iterator>);
+static_assert(std::same_as<stdr::iterator_t<std::deque<int> const>,
+                           std::deque<int>::const_iterator>);
+
+static_assert(
+    std::same_as<stdr::iterator_t<std::list<int> >, std::list<int>::iterator>);
+static_assert(std::same_as<stdr::iterator_t<std::list<int> const>,
+                           std::list<int>::const_iterator>);
+
+static_assert(std::same_as<stdr::iterator_t<std::vector<int> >,
+                           std::vector<int>::iterator>);
+static_assert(std::same_as<stdr::iterator_t<std::vector<int> const>,
+                           std::vector<int>::const_iterator>);

libcxx/test/support/test_macros.h

 #if !defined(__cpp_impl_three_way_comparison) \
     && (!defined(_MSC_VER) || defined(__clang__) || _MSC_VER < 1920 || _MSVC_LANG <= 201703L)
 #define TEST_HAS_NO_SPACESHIP_OPERATOR
 #endif
 
 #if TEST_STD_VER < 11
 #define ASSERT_NOEXCEPT(...)
 #define ASSERT_NOT_NOEXCEPT(...)
+#define CONSTEXPR_ASSERT(...)
 #else
 #define ASSERT_NOEXCEPT(...) \
     static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
 
 #define ASSERT_NOT_NOEXCEPT(...) \
     static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept")
+
+#define CONSTEXPR_ASSERT(...)                                                  \
+  static_assert(__VA_ARGS__);                                                  \
+  assert((__VA_ARGS__))
 #endif
 
 /* Macros for testing libc++ specific behavior and extensions */
 #if defined(_LIBCPP_VERSION)
 #define LIBCPP_ASSERT(...) assert(__VA_ARGS__)
 #define LIBCPP_STATIC_ASSERT(...) static_assert(__VA_ARGS__)
 #define LIBCPP_ASSERT_NOEXCEPT(...) ASSERT_NOEXCEPT(__VA_ARGS__)
 #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ASSERT_NOT_NOEXCEPT(__VA_ARGS__)