diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -132,6 +132,8 @@
   queue
   random
   ratio
+  ranges
+  __ranges/access.h
   regex
   scoped_allocator
   semaphore
diff --git a/libcxx/include/__ranges/access.h b/libcxx/include/__ranges/access.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/access.h
@@ -0,0 +1,200 @@
+// -*- 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
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -409,6 +409,13 @@
     export initializer_list
     export *
   }
+  module ranges {
+    header "ranges"
+    export compare
+    export initializer_list
+    export iterator
+    export *
+  }
   module ratio {
     header "ratio"
     export *
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
new file mode 100644
--- /dev/null
+++ b/libcxx/include/ranges
@@ -0,0 +1,28 @@
+// #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
diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -2811,9 +2811,9 @@
 }
 
 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);
 }
diff --git a/libcxx/test/libcxx/ranges/range.access/access.h b/libcxx/test/libcxx/ranges/range.access/access.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/ranges/range.access/access.h
@@ -0,0 +1,470 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
diff --git a/libcxx/test/libcxx/ranges/range.access/range.access.begin/begin.compile.pass.cpp b/libcxx/test/libcxx/ranges/range.access/range.access.begin/begin.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/ranges/range.access/range.access.begin/begin.compile.pass.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+// 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);
diff --git a/libcxx/test/libcxx/ranges/range.access/range.access.end/end.compile.pass.cpp b/libcxx/test/libcxx/ranges/range.access/range.access.end/end.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/ranges/range.access/range.access.end/end.compile.pass.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+// 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);
diff --git a/libcxx/test/std/ranges/range.access/array_access.h b/libcxx/test/std/ranges/range.access/array_access.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/array_access.h
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
diff --git a/libcxx/test/std/ranges/range.access/member_access.h b/libcxx/test/std/ranges/range.access/member_access.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/member_access.h
@@ -0,0 +1,119 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
diff --git a/libcxx/test/std/ranges/range.access/range.access.begin/array_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.begin/array_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.begin/array_access.pass.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// 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);
diff --git a/libcxx/test/std/ranges/range.access/range.access.begin/member_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.begin/member_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.begin/member_access.pass.cpp
@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/range.access.begin/unqualified_lookup.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.begin/unqualified_lookup.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.begin/unqualified_lookup.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/range.access.cbegin/array_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.cbegin/array_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.cbegin/array_access.pass.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// 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);
diff --git a/libcxx/test/std/ranges/range.access/range.access.cbegin/member_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.cbegin/member_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.cbegin/member_access.pass.cpp
@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/range.access.cbegin/unqualified_lookup.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.cbegin/unqualified_lookup.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.cbegin/unqualified_lookup.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/range.access.cend/array_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.cend/array_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.cend/array_access.pass.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// 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);
diff --git a/libcxx/test/std/ranges/range.access/range.access.cend/member_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.cend/member_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.cend/member_access.pass.cpp
@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/range.access.cend/unqualified_lookup.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.cend/unqualified_lookup.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.cend/unqualified_lookup.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/range.access.end/array_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.end/array_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.end/array_access.pass.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// 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);
diff --git a/libcxx/test/std/ranges/range.access/range.access.end/member_access.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.end/member_access.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.end/member_access.pass.cpp
@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/range.access.end/unqualified_lookup.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.end/unqualified_lookup.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.end/unqualified_lookup.pass.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
diff --git a/libcxx/test/std/ranges/range.access/unqualified_lookup_access.h b/libcxx/test/std/ranges/range.access/unqualified_lookup_access.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/unqualified_lookup_access.h
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
diff --git a/libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp b/libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.range/iterator_t.compile.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>);
diff --git a/libcxx/test/support/test_macros.h b/libcxx/test/support/test_macros.h
--- a/libcxx/test/support/test_macros.h
+++ b/libcxx/test/support/test_macros.h
@@ -289,12 +289,17 @@
 #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 */