diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -35,6 +35,7 @@
   __mutex_base
   __node_handle
   __nullptr
+  __ranges/access.h
   __ranges/enable_borrowed_range.h
   __split_buffer
   __sso_allocator
@@ -150,6 +151,7 @@
   random
   ranges
   ratio
+  ranges
   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,217 @@
+// -*- C++ -*-
+//===------------------------ __ranges/begin.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 _LIBCPP___RANGES_ACCESS_H
+#define _LIBCPP___RANGES_ACCESS_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__ranges/enable_borrowed_range.h>
+#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)
+
+// clang-format off
+
+namespace ranges {
+  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); };
+} // namespace ranges
+
+// [range.access.begin]
+namespace ranges::__begin {
+  template <class _Tp>
+  concept __member_begin =
+    __can_borrow<_Tp> &&
+    requires(_Tp&& __t) {
+      { _VSTD::__decay_copy(__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<remove_cvref_t<_Tp> > &&
+    requires(_Tp && __t) {
+      { _VSTD::__decay_copy(begin(__t)) } -> input_or_output_iterator;
+    };
+
+  struct __fn {
+    template <class _Tp, size_t _Np>
+    [[nodiscard]] constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept {
+      constexpr bool __complete = __is_complete<remove_cv_t<_Tp> >;
+      if constexpr (__complete) { // used to disable cryptic diagnostic
+        return __t + 0;
+      }
+      else {
+        static_assert(__complete, "`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type.");
+      }
+    }
+
+    template <class _Tp>
+    requires __member_begin<_Tp>
+    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_VSTD::__decay_copy(__t.begin())))
+    {
+      return __t.begin();
+    }
+
+    template <class _Tp>
+    requires __unqualified_begin<_Tp>
+    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_VSTD::__decay_copy(begin(__t))))
+    {
+      return begin(__t);
+    }
+
+    void operator()(auto&&) const = delete;
+  };
+} // namespace ranges::__begin
+
+namespace ranges {
+  inline namespace __cpo {
+    inline constexpr auto begin = __begin::__fn{};
+  } // namespace __cpo
+
+  template <class _Tp>
+  using iterator_t = decltype(ranges::begin(declval<_Tp&>()));
+} // namespace ranges
+
+// [range.access.end]
+namespace ranges::__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<remove_cvref_t<_Tp> > &&
+    requires(_Tp && __t) {
+      typename iterator_t<_Tp>;
+      { _VSTD::__decay_copy(end(_VSTD::forward<_Tp>(__t))) } -> sentinel_for<iterator_t<_Tp> >;
+    };
+
+  class __fn {
+  public:
+    template <class _Tp, size_t _Np>
+    [[nodiscard]] constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept {
+      constexpr bool __complete = __is_complete<remove_cv_t<_Tp> >;
+      if constexpr (__complete) { // used to disable cryptic diagnostic
+        return __t + _Np;
+      }
+      else {
+        static_assert(__complete, "`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type.");
+      }
+    }
+
+    template <class _Tp>
+    requires __member_end<_Tp>
+    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_VSTD::__decay_copy(__t.end())))
+    {
+      return _VSTD::forward<_Tp>(__t).end();
+    }
+
+    template <class _Tp>
+    requires __unqualified_end<_Tp>
+    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(_VSTD::__decay_copy(end(__t))))
+    {
+      return end(__t);
+    }
+
+    void operator()(auto&&) const = delete;
+  };
+} // namespace ranges::__end
+
+namespace ranges::inline __cpo {
+  inline constexpr auto end = __end::__fn{};
+} // namespace ranges::__cpo
+
+namespace ranges::__cbegin {
+  struct __fn {
+    template <class _Tp>
+    requires invocable<decltype(ranges::begin), _Tp const&>
+    [[nodiscard]] constexpr auto operator()(_Tp& __t) const
+    noexcept(noexcept(ranges::begin(_VSTD::as_const(__t))))
+    {
+      return ranges::begin(_VSTD::as_const(__t));
+    }
+
+    template <class _Tp>
+    requires is_rvalue_reference_v<_Tp> && invocable<decltype(ranges::begin), _Tp const&&>
+    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(ranges::begin(static_cast<_Tp const&&>(__t))))
+    {
+      return ranges::begin(static_cast<_Tp const&&>(__t));
+    }
+  };
+} // namespace ranges::__cbegin
+
+namespace ranges::inline __cpo {
+  inline constexpr auto cbegin = __cbegin::__fn{};
+} // namespace ranges::__cpo
+
+namespace ranges::__cend {
+  struct __fn {
+    template <class _Tp>
+    requires invocable<decltype(ranges::end), _Tp const&>
+    [[nodiscard]] constexpr auto operator()(_Tp& __t) const
+    noexcept(noexcept(ranges::end(_VSTD::as_const(__t))))
+    {
+      return ranges::end(_VSTD::as_const(__t));
+    }
+
+    template <class _Tp>
+    requires is_rvalue_reference_v<_Tp> && invocable<decltype(ranges::end), _Tp const&&>
+    [[nodiscard]] constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(ranges::end(static_cast<_Tp const&&>(__t))))
+    {
+      return ranges::end(static_cast<_Tp const&&>(__t));
+    }
+  };
+} // namespace ranges::__cend
+
+namespace ranges::inline __cpo {
+  inline constexpr auto cend = __cend::__fn{};
+} // namespace ranges::__cpo
+
+// clang-format off
+
+#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
@@ -411,6 +411,9 @@
   }
   module ranges {
     header "ranges"
+    export compare
+    export initializer_list
+    export iterator
     export *
   }
   module ratio {
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -17,14 +17,26 @@
 #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>
     inline constexpr bool enable_borrowed_range = false;
+
+  template<class T>
+    using iterator_t = decltype(ranges::begin(declval<T&>()));
 }
 
 */
 
 #include <__config>
+#include <__ranges/access.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -2814,6 +2814,9 @@
 inline _LIBCPP_INLINE_VISIBILITY
 typename decay<_Tp>::type
 __decay_copy(_Tp&& __t)
+#if _LIBCPP_STD_VER > 17
+noexcept(is_nothrow_convertible_v<_Tp, remove_reference_t<_Tp>>)
+#endif
 {
     return _VSTD::forward<_Tp>(__t);
 }
diff --git a/libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// map
+
+#include <map>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::map<int, int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// multimap
+
+#include <map>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::multimap<int, int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// multiset
+
+#include <set>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::multiset<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// set
+
+#include <set>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::set<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// array
+
+#include <array>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::array<int, 10>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// deque
+
+#include <deque>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::deque<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// forward_list
+
+#include <forward_list>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::forward_list<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// list
+
+#include <list>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::list<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// vector
+
+#include <vector>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::vector<bool>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// vector
+
+#include <vector>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::vector<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// unordered_map
+
+#include <unordered_map>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::unordered_map<int, int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// unordered_multimap
+
+#include <unordered_map>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::unordered_multimap<int, int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// unordered_multiset
+
+#include <unordered_set>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::unordered_multiset<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// unordered_multiset
+
+#include <unordered_set>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::unordered_set<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
diff --git a/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// span
+
+#include <span>
+
+#include <concepts>
+#include <ranges>
+
+using range = std::span<int>;
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// directory_iterator, recursive_directory_iterator
+
+#include "filesystem_include.h"
+
+#include <concepts>
+#include <ranges>
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
+static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
+static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
+static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
diff --git a/libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// path
+
+#include "filesystem_include.h"
+
+#include <concepts>
+#include <ranges>
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<fs::path>, fs::path::iterator>);
+static_assert(std::same_as<stdr::iterator_t<fs::path const>, fs::path::const_iterator>);
diff --git a/libcxx/test/std/ranges/range.access/begin.h b/libcxx/test/std/ranges/range.access/begin.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/begin.h
@@ -0,0 +1,485 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_STD_TEST_RANGE_ACCESS_BEGIN_H
+#define LIBCXX_STD_TEST_RANGE_ACCESS_BEGIN_H
+
+#include <ranges>
+
+// clang-format off
+
+enum class enable_constness { mutable_only, const_only, both };
+enum called { neither, member, adl, both };
+constexpr bool borrowed = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct member_only {
+  constexpr int* begin()
+  requires (Const != enable_constness::const_only) {
+    callee |= called::member;
+    return &value;
+  }
+
+  constexpr int const* begin() const
+  requires (Const != enable_constness::mutable_only) {
+    callee |= called::member;
+    return &value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<member_only<Const, true> > = true;
+
+template<enable_constness Const, bool>
+struct lvalue_member_only {
+  constexpr int* begin() &
+  requires (Const != enable_constness::const_only) {
+    callee |= called::member;
+    return &value;
+  }
+
+  constexpr int const* begin() const&
+  requires (Const != enable_constness::mutable_only) {
+    callee |= called::member;
+    return &value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool
+std::ranges::enable_borrowed_range<lvalue_member_only<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct rvalue_member_only {
+  constexpr int* begin() &&
+  requires (Const != enable_constness::const_only) {
+    callee |= called::member;
+    return &value;
+  }
+
+  constexpr int const* begin() const&&
+  requires (Const != enable_constness::mutable_only) {
+    callee |= called::member;
+    return &value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_member_only<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct member_preferred : member_only<Const, is_borrowed> {
+  constexpr friend int* begin(member_preferred& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(member_preferred const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<member_preferred<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct lvalue_member_preferred : lvalue_member_only<Const, is_borrowed> {
+  constexpr friend int* begin(lvalue_member_preferred& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(lvalue_member_preferred const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<lvalue_member_preferred<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct rvalue_member_preferred : rvalue_member_only<Const, is_borrowed> {
+  constexpr friend int* begin(rvalue_member_preferred&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(rvalue_member_preferred const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_member_preferred<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct lvalue_adl_only {
+  constexpr friend int* begin(lvalue_adl_only& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(lvalue_adl_only const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<lvalue_adl_only<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct rvalue_adl_only {
+  constexpr friend int* begin(rvalue_adl_only&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(rvalue_adl_only const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_adl_only<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct adl_only {
+  constexpr friend int* begin(adl_only& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(adl_only const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int* begin(adl_only&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(adl_only const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<adl_only<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct lvalue_adl_with_private_members : private member_only<Const, is_borrowed> {
+  constexpr friend int* begin(lvalue_adl_with_private_members& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(lvalue_adl_with_private_members const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<lvalue_adl_with_private_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct lvalue_adl_with_private_lvalue_members : private lvalue_member_only<Const, is_borrowed> {
+  constexpr friend int* begin(lvalue_adl_with_private_lvalue_members& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(lvalue_adl_with_private_lvalue_members const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<lvalue_adl_with_private_lvalue_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct lvalue_adl_with_private_rvalue_members : private rvalue_member_only<Const, is_borrowed> {
+  constexpr friend int* begin(lvalue_adl_with_private_rvalue_members& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(lvalue_adl_with_private_rvalue_members const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<lvalue_adl_with_private_rvalue_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct rvalue_adl_with_private_members : private member_only<Const, is_borrowed> {
+  constexpr friend int* begin(rvalue_adl_with_private_members&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(rvalue_adl_with_private_members const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_adl_with_private_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct rvalue_adl_with_private_lvalue_members : private lvalue_member_only<Const, is_borrowed> {
+  constexpr friend int* begin(rvalue_adl_with_private_lvalue_members&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(rvalue_adl_with_private_lvalue_members const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_adl_with_private_lvalue_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool is_borrowed>
+struct rvalue_adl_with_private_rvalue_members : private rvalue_member_only<Const, is_borrowed> {
+  constexpr friend int* begin(rvalue_adl_with_private_rvalue_members&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(rvalue_adl_with_private_rvalue_members const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_adl_with_private_rvalue_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct lvalue_adl_with_bad_members {
+  constexpr int begin() {
+    callee |= called::member;
+    return value;
+  }
+
+  constexpr int begin() const {
+    callee |= called::member;
+    return value;
+  }
+
+  constexpr friend int* begin(lvalue_adl_with_bad_members& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(lvalue_adl_with_bad_members const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = called::neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<lvalue_adl_with_bad_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct rvalue_adl_with_bad_members {
+  constexpr int begin() {
+    callee |= called::member;
+    return value;
+  }
+
+  constexpr int begin() const {
+    callee |= called::member;
+    return value;
+  }
+
+  constexpr friend int* begin(rvalue_adl_with_bad_members&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(rvalue_adl_with_bad_members const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  mutable int callee = called::neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_adl_with_bad_members<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct lvalue_adl_with_data_member_begin {
+  constexpr friend int* begin(lvalue_adl_with_data_member_begin& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(lvalue_adl_with_data_member_begin const& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  int begin = 0;
+  mutable int callee = called::neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<lvalue_adl_with_data_member_begin<Const, borrowed> > = true;
+
+template<enable_constness Const, bool>
+struct rvalue_adl_with_data_member_begin {
+  constexpr friend int* begin(rvalue_adl_with_data_member_begin&& x)
+  requires (Const != enable_constness::const_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  constexpr friend int const* begin(rvalue_adl_with_data_member_begin const&& x)
+  requires (Const != enable_constness::mutable_only) {
+    x.callee |= called::adl;
+    return &x.value;
+  }
+
+  int value = 0;
+  int begin = 0;
+  mutable int callee = called::neither;
+};
+
+template<enable_constness Const>
+inline constexpr bool std::ranges::enable_borrowed_range<rvalue_adl_with_data_member_begin<Const, borrowed> > = true;
+
+struct empty {};
+template<> inline constexpr bool std::ranges::enable_borrowed_range<empty> = true;
+
+struct bad_member_return {
+  int begin();
+  int begin() const;
+};
+
+template<> inline constexpr bool std::ranges::enable_borrowed_range<bad_member_return> = true;
+
+struct member_returns_decayable {
+  int*& begin();
+  int*& begin() const;
+};
+
+struct adl_returns_decayable {
+  friend int*& begin(adl_returns_decayable&);
+  friend int*& begin(adl_returns_decayable const&);
+};
+
+template<class T>
+struct nothrow_member_begin {
+  T begin() noexcept;
+  T begin() const noexcept;
+};
+
+template<class T>
+struct nothrow_adl_begin {
+  friend T begin(nothrow_adl_begin&) noexcept;
+  friend T begin(nothrow_adl_begin const&) noexcept;
+};
+
+// clang-format on
+
+#endif // LIBCXX_STD_TEST_RANGE_ACCESS_BEGIN_H
diff --git a/libcxx/test/std/ranges/range.access/range.access.begin/begin.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.begin/begin.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.begin/begin.pass.cpp
@@ -0,0 +1,337 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// ranges::begin
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <iterator>
+
+#include "../begin.h"
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+using begin_t = decltype(std::ranges::begin);
+
+static_assert(std::semiregular<std::remove_cv_t<begin_t> >);
+static_assert(std::invocable<begin_t&, int (&)[10]>);
+static_assert(!std::invocable<begin_t&, int(&&)[10]>);
+static_assert(!std::invocable<begin_t&, int (&)[]>);
+static_assert(!std::invocable<begin_t&, int(&&)[]>);
+ASSERT_NOEXCEPT(std::ranges::begin(std::declval<int (&)[10]>()));
+
+// clang-format off
+template <class T>
+concept invocable_member_with_desired_result =
+  std::invocable<begin_t&, T> &&
+  requires(T&& t) {
+    { std::ranges::begin(std::forward<T>(t)) } -> std::same_as<std::decay_t<decltype(t.begin())> >;
+  };
+
+template <class T>
+concept invocable_adl_with_desired_result =
+  std::invocable<begin_t&, T> &&
+  requires(T&& t) {
+    { std::ranges::begin(std::forward<T>(t)) } -> std::same_as<std::decay_t<decltype(begin(t))> >;
+  };
+// clang-format on
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_lvalue_member() {
+  constexpr bool result = invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&>;
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&>);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed>&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed> const&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::both, is_borrowed>&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::both, is_borrowed> const&> == result);
+  return result;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_rvalue_member() {
+  constexpr bool result = invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&&>;
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&&>);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed>&&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed> const&&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::both, is_borrowed>&&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::both, is_borrowed> const&&> == result);
+  return result;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_lvalue_adl() {
+  constexpr bool result = invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&>;
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&>);
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed>&>);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed> const&> == result);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed>&> == result);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed> const&> == result);
+  return result;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_rvalue_adl() {
+  constexpr bool result = invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&&>;
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&&>);
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed>&&>);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed> const&&> == result);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed>&&> == result);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed> const&&> == result);
+  return result;
+}
+
+static_assert(check_invocable_lvalue_member<member_only, !borrowed>());
+static_assert(!check_invocable_rvalue_member<member_only, !borrowed>());
+static_assert(check_invocable_lvalue_member<member_only, borrowed>());
+static_assert(check_invocable_rvalue_member<member_only, borrowed>());
+
+static_assert(check_invocable_lvalue_member<lvalue_member_only, !borrowed>());
+static_assert(!check_invocable_rvalue_member<lvalue_member_only, !borrowed>());
+static_assert(check_invocable_lvalue_member<lvalue_member_only, borrowed>());
+static_assert(check_invocable_rvalue_member<lvalue_member_only, borrowed>());
+
+static_assert(!check_invocable_lvalue_member<rvalue_member_only, !borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_only, !borrowed>());
+static_assert(!check_invocable_lvalue_member<rvalue_member_only, borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_only, borrowed>());
+
+static_assert(check_invocable_lvalue_member<member_preferred, !borrowed>());
+static_assert(!check_invocable_rvalue_member<member_preferred, !borrowed>());
+static_assert(check_invocable_lvalue_member<member_preferred, borrowed>());
+static_assert(check_invocable_rvalue_member<member_preferred, borrowed>());
+
+static_assert(check_invocable_lvalue_member<lvalue_member_preferred, !borrowed>());
+static_assert(!check_invocable_rvalue_member<lvalue_member_preferred, !borrowed>());
+static_assert(check_invocable_lvalue_member<lvalue_member_preferred, borrowed>());
+static_assert(check_invocable_rvalue_member<lvalue_member_preferred, borrowed>());
+
+static_assert(!check_invocable_lvalue_member<rvalue_member_preferred, !borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_preferred, !borrowed>());
+static_assert(!check_invocable_lvalue_member<rvalue_member_preferred, borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_preferred, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_only, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<lvalue_adl_only, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_only, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_only, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_only, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_only, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_only, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_only, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<adl_only, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<adl_only, !borrowed>());
+static_assert(check_invocable_lvalue_adl<adl_only, borrowed>());
+static_assert(check_invocable_rvalue_adl<adl_only, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<lvalue_adl_with_private_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<lvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_lvalue_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_lvalue_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<lvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_rvalue_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_rvalue_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_lvalue_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_lvalue_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_rvalue_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_rvalue_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_bad_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<lvalue_adl_with_bad_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_bad_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_bad_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_bad_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_bad_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_bad_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_bad_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<lvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_data_member_begin, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_data_member_begin, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_data_member_begin, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_data_member_begin, borrowed>());
+
+static_assert(!std::invocable<begin_t&, empty&>);
+static_assert(!std::invocable<begin_t&, empty const&>);
+static_assert(!std::invocable<begin_t&, empty&&>);
+static_assert(!std::invocable<begin_t&, empty const&&>);
+
+static_assert(!std::invocable<begin_t&, bad_member_return&>);
+static_assert(!std::invocable<begin_t&, bad_member_return const&>);
+static_assert(!std::invocable<begin_t&, bad_member_return&&>);
+static_assert(!std::invocable<begin_t&, bad_member_return const&&>);
+
+static_assert(std::invocable<begin_t&, member_returns_decayable&>);
+static_assert(std::invocable<begin_t&, member_returns_decayable const&>);
+
+static_assert(std::invocable<begin_t&, adl_returns_decayable&>);
+static_assert(std::invocable<begin_t&, adl_returns_decayable const&>);
+
+ASSERT_NOEXCEPT(std::ranges::begin(std::declval<nothrow_member_begin<int*>&>()));
+ASSERT_NOT_NOEXCEPT(std::ranges::begin(std::declval<nothrow_member_begin<ThrowingIterator<int> >&>()));
+ASSERT_NOEXCEPT(std::ranges::begin(std::declval<nothrow_adl_begin<int*>&>()));
+ASSERT_NOT_NOEXCEPT(std::ranges::begin(std::declval<nothrow_adl_begin<ThrowingIterator<int> >&>()));
+
+template <typename T, std::same_as<T>... Ts>
+constexpr bool check_lvalue_array(T t, Ts... ts) {
+  T x[] = {t, ts...};
+  return std::ranges::begin(x) == &x[0];
+}
+
+template <class T>
+[[nodiscard]] constexpr bool check_member_impl() {
+  std::remove_cvref_t<T> t;
+  return std::ranges::begin(std::forward<T>(t)) == std::forward<T>(t).begin() && t.callee == called::member;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_member_with_lvalue_param() {
+  static_assert(check_member_impl<T<enable_constness::mutable_only, is_borrowed>&>());
+  assert((check_member_impl<T<enable_constness::mutable_only, is_borrowed>&>()));
+  // static_assert(check_lvalue_member_impl<T<enable_constness::mutable_only, is_borrowed> const&>());
+  // assert((check_lvalue_member_impl<T<enable_constness::mutable_only, is_borrowed> const&>()));
+  static_assert(check_member_impl<T<enable_constness::const_only, is_borrowed>&>());
+  assert((check_member_impl<T<enable_constness::const_only, is_borrowed>&>()));
+  static_assert(check_member_impl<T<enable_constness::const_only, is_borrowed> const&>());
+  assert((check_member_impl<T<enable_constness::const_only, is_borrowed> const&>()));
+  static_assert(check_member_impl<T<enable_constness::both, is_borrowed>&>());
+  assert((check_member_impl<T<enable_constness::both, is_borrowed>&>()));
+  static_assert(check_member_impl<T<enable_constness::both, is_borrowed> const&>());
+  assert((check_member_impl<T<enable_constness::both, is_borrowed> const&>()));
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_member_with_rvalue_param() {
+  static_assert(check_member_impl<T<enable_constness::mutable_only, is_borrowed>&&>());
+  assert((check_member_impl<T<enable_constness::mutable_only, is_borrowed>&&>()));
+  // static_assert(check_rvalue_member_impl<T<enable_constness::mutable_only, is_borrowed> const&&>());
+  // assert((check_rvalue_member_impl<T<enable_constness::mutable_only, is_borrowed> const&&>()));
+  static_assert(check_member_impl<T<enable_constness::const_only, is_borrowed>&&>());
+  assert((check_member_impl<T<enable_constness::const_only, is_borrowed>&&>()));
+  static_assert(check_member_impl<T<enable_constness::const_only, is_borrowed> const&&>());
+  assert((check_member_impl<T<enable_constness::const_only, is_borrowed> const&&>()));
+  static_assert(check_member_impl<T<enable_constness::both, is_borrowed>&&>());
+  assert((check_member_impl<T<enable_constness::both, is_borrowed>&&>()));
+  static_assert(check_member_impl<T<enable_constness::both, is_borrowed> const&&>());
+  assert((check_member_impl<T<enable_constness::both, is_borrowed> const&&>()));
+}
+
+template <class T>
+[[nodiscard]] constexpr bool check_adl_impl() {
+  std::remove_cvref_t<T> t;
+  using std::begin;
+  return std::ranges::begin(std::forward<T>(t)) == begin(std::forward<T>(t)) && t.callee == called::adl;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_adl_with_lvalue_param() {
+  static_assert(check_adl_impl<T<enable_constness::mutable_only, is_borrowed>&>());
+  assert((check_adl_impl<T<enable_constness::mutable_only, is_borrowed>&>()));
+  static_assert(check_adl_impl<T<enable_constness::const_only, is_borrowed> const&>());
+  assert((check_adl_impl<T<enable_constness::const_only, is_borrowed> const&>()));
+  static_assert(check_adl_impl<T<enable_constness::both, is_borrowed>&>());
+  assert((check_adl_impl<T<enable_constness::both, is_borrowed>&>()));
+  static_assert(check_adl_impl<T<enable_constness::both, is_borrowed> const&>());
+  assert((check_adl_impl<T<enable_constness::both, is_borrowed> const&>()));
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_adl_with_rvalue_param() {
+  static_assert(check_adl_impl<T<enable_constness::mutable_only, is_borrowed>&&>());
+  assert((check_adl_impl<T<enable_constness::mutable_only, is_borrowed>&&>()));
+  static_assert(check_adl_impl<T<enable_constness::const_only, is_borrowed> const&&>());
+  assert((check_adl_impl<T<enable_constness::const_only, is_borrowed> const&&>()));
+  static_assert(check_adl_impl<T<enable_constness::both, is_borrowed>&&>());
+  assert((check_adl_impl<T<enable_constness::both, is_borrowed>&&>()));
+  static_assert(check_adl_impl<T<enable_constness::both, is_borrowed> const&&>());
+  assert((check_adl_impl<T<enable_constness::both, is_borrowed> const&&>()));
+}
+
+int main() {
+  struct S {
+    int x;
+  };
+
+  static_assert(check_lvalue_array(0, 1, 2, 3, 4, 5));
+  assert((check_lvalue_array(0, 1, 2, 3, 4, 5)));
+
+  static_assert(check_lvalue_array(0.0, 1.0));
+  assert((check_lvalue_array(0.0, 1.0)));
+
+  static_assert(check_lvalue_array(S{0}, S{1}, S{2}));
+  assert((check_lvalue_array(S{0}, S{1}, S{2})));
+
+  check_member_with_lvalue_param<member_only, !borrowed>();
+  check_member_with_lvalue_param<member_only, borrowed>();
+  check_member_with_rvalue_param<member_only, borrowed>();
+
+  check_member_with_lvalue_param<lvalue_member_only, !borrowed>();
+  check_member_with_lvalue_param<lvalue_member_only, borrowed>();
+
+  check_member_with_lvalue_param<member_preferred, !borrowed>();
+  check_member_with_lvalue_param<member_preferred, borrowed>();
+  check_member_with_rvalue_param<member_preferred, borrowed>();
+
+  check_member_with_lvalue_param<lvalue_member_preferred, !borrowed>();
+  check_member_with_lvalue_param<lvalue_member_preferred, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_only, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_only, borrowed>();
+
+  check_adl_with_lvalue_param<adl_only, !borrowed>();
+  check_adl_with_lvalue_param<adl_only, borrowed>();
+  check_adl_with_rvalue_param<adl_only, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_private_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_private_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_private_lvalue_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_private_lvalue_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_private_rvalue_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_private_rvalue_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_bad_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_bad_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_data_member_begin, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_data_member_begin, borrowed>();
+}
diff --git a/libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp b/libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.begin/incomplete.compile.verify.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// unspecified begin;
+
+#include <ranges>
+
+#include <type_traits>
+
+// clang-format off
+template <class T>
+requires(!std::invocable<std::ranges::__begin::__fn, T>)
+void f() {}
+// clang-format on
+
+void test() {
+  struct incomplete;
+  f<incomplete(&)[10]>();
+  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
+  // expected-error@-2 {{no matching function for call to 'f'}}
+
+  // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
+  f<incomplete(&&)[10]>();
+}
diff --git a/libcxx/test/std/ranges/range.access/range.access.cbegin/cbegin.pass.cpp b/libcxx/test/std/ranges/range.access/range.access.cbegin/cbegin.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.access/range.access.cbegin/cbegin.pass.cpp
@@ -0,0 +1,316 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// ranges::cbegin
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <iterator>
+
+#include "../begin.h"
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+using cbegin_t = decltype(std::ranges::cbegin);
+
+static_assert(std::semiregular<std::remove_cv_t<cbegin_t> >);
+static_assert(std::invocable<cbegin_t&, int (&)[10]>);
+static_assert(!std::invocable<cbegin_t&, int(&&)[10]>);
+static_assert(!std::invocable<cbegin_t&, int (&)[]>);
+static_assert(!std::invocable<cbegin_t&, int(&&)[]>);
+ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<int (&)[10]>()));
+
+// clang-format off
+template <class T>
+concept invocable_member_with_desired_result =
+  std::invocable<cbegin_t&, T> &&
+  requires(T&& t) {
+    { std::ranges::cbegin(std::forward<T>(t)) } -> std::same_as<std::decay_t<decltype(std::as_const(t).begin())> >;
+  };
+
+template <class T>
+concept invocable_adl_with_desired_result =
+  std::invocable<cbegin_t&, T> &&
+  requires(T&& t) {
+    { std::ranges::cbegin(std::forward<T>(t)) } -> std::same_as<std::decay_t<decltype(begin(std::as_const(t)))> >;
+  };
+// clang-format on
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_lvalue_member() {
+  constexpr bool result = invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed>&>;
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&>);
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&>);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed> const&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::both, is_borrowed>&> == result);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::both, is_borrowed> const&> == result);
+  return result;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_rvalue_member() {
+  constexpr bool result = invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed> const&&>;
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&&>);
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&&>);
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::const_only, is_borrowed>&&>);
+  static_assert(!invocable_member_with_desired_result<T<enable_constness::both, is_borrowed>&&>);
+  static_assert(invocable_member_with_desired_result<T<enable_constness::both, is_borrowed> const&&> == result);
+  return result;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_lvalue_adl() {
+  constexpr bool result = invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed> const&>;
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&>);
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&>);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed>&> == result);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed>&> == result);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed> const&> == result);
+  return result;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+[[nodiscard]] consteval bool check_invocable_rvalue_adl() {
+  constexpr bool result = invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed> const&&>;
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed>&&>);
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::mutable_only, is_borrowed> const&&>);
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::const_only, is_borrowed>&&>);
+  static_assert(!invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed>&&>);
+  static_assert(invocable_adl_with_desired_result<T<enable_constness::both, is_borrowed> const&&> == result);
+  return result;
+}
+
+static_assert(check_invocable_lvalue_member<member_only, !borrowed>());
+static_assert(check_invocable_rvalue_member<member_only, !borrowed>());
+static_assert(check_invocable_lvalue_member<member_only, borrowed>());
+static_assert(check_invocable_rvalue_member<member_only, borrowed>());
+
+static_assert(check_invocable_lvalue_member<lvalue_member_only, !borrowed>());
+static_assert(check_invocable_rvalue_member<lvalue_member_only, !borrowed>());
+static_assert(check_invocable_lvalue_member<lvalue_member_only, borrowed>());
+static_assert(check_invocable_rvalue_member<lvalue_member_only, borrowed>());
+
+static_assert(!check_invocable_lvalue_member<rvalue_member_only, !borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_only, !borrowed>());
+static_assert(!check_invocable_lvalue_member<rvalue_member_only, borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_only, borrowed>());
+
+static_assert(check_invocable_lvalue_member<member_preferred, !borrowed>());
+static_assert(check_invocable_rvalue_member<member_preferred, !borrowed>());
+static_assert(check_invocable_lvalue_member<member_preferred, borrowed>());
+static_assert(check_invocable_rvalue_member<member_preferred, borrowed>());
+
+static_assert(check_invocable_lvalue_member<lvalue_member_preferred, !borrowed>());
+static_assert(check_invocable_rvalue_member<lvalue_member_preferred, !borrowed>());
+static_assert(check_invocable_lvalue_member<lvalue_member_preferred, borrowed>());
+static_assert(check_invocable_rvalue_member<lvalue_member_preferred, borrowed>());
+
+static_assert(!check_invocable_lvalue_member<rvalue_member_preferred, !borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_preferred, !borrowed>());
+static_assert(!check_invocable_lvalue_member<rvalue_member_preferred, borrowed>());
+static_assert(!check_invocable_rvalue_member<rvalue_member_preferred, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_only, !borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_only, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_only, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_only, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_only, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_only, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_only, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_only, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<adl_only, !borrowed>());
+static_assert(check_invocable_rvalue_adl<adl_only, !borrowed>());
+static_assert(check_invocable_lvalue_adl<adl_only, borrowed>());
+static_assert(check_invocable_rvalue_adl<adl_only, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_members, !borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_lvalue_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_lvalue_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_private_rvalue_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_private_rvalue_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_lvalue_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_lvalue_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_lvalue_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_rvalue_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_private_rvalue_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_private_rvalue_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_bad_members, !borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_bad_members, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_bad_members, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_bad_members, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_bad_members, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_bad_members, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_bad_members, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_bad_members, borrowed>());
+
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(check_invocable_lvalue_adl<lvalue_adl_with_data_member_begin, borrowed>());
+static_assert(check_invocable_rvalue_adl<lvalue_adl_with_data_member_begin, borrowed>());
+
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_data_member_begin, !borrowed>());
+static_assert(!check_invocable_lvalue_adl<rvalue_adl_with_data_member_begin, borrowed>());
+static_assert(!check_invocable_rvalue_adl<rvalue_adl_with_data_member_begin, borrowed>());
+
+static_assert(!std::invocable<cbegin_t&, empty&>);
+static_assert(!std::invocable<cbegin_t&, empty const&>);
+static_assert(!std::invocable<cbegin_t&, empty&&>);
+static_assert(!std::invocable<cbegin_t&, empty const&&>);
+
+static_assert(!std::invocable<cbegin_t&, bad_member_return&>);
+static_assert(!std::invocable<cbegin_t&, bad_member_return const&>);
+static_assert(!std::invocable<cbegin_t&, bad_member_return&&>);
+static_assert(!std::invocable<cbegin_t&, bad_member_return const&&>);
+
+static_assert(std::invocable<cbegin_t&, member_returns_decayable&>);
+static_assert(std::invocable<cbegin_t&, member_returns_decayable const&>);
+
+static_assert(std::invocable<cbegin_t&, adl_returns_decayable&>);
+static_assert(std::invocable<cbegin_t&, adl_returns_decayable const&>);
+
+ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<nothrow_member_begin<int*>&>()));
+ASSERT_NOT_NOEXCEPT(std::ranges::cbegin(std::declval<nothrow_member_begin<ThrowingIterator<int> >&>()));
+ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<nothrow_adl_begin<int*>&>()));
+ASSERT_NOT_NOEXCEPT(std::ranges::cbegin(std::declval<nothrow_adl_begin<ThrowingIterator<int> >&>()));
+
+template <typename T, std::same_as<T>... Ts>
+constexpr bool check_lvalue_array(T t, Ts... ts) {
+  T x[] = {t, ts...};
+  return std::ranges::cbegin(x) == &x[0];
+}
+
+template <class T>
+[[nodiscard]] constexpr bool check_member_impl() {
+  std::remove_cvref_t<T> t;
+  return std::ranges::cbegin(std::forward<T>(t)) == std::forward<T>(t).begin() && t.callee == called::member;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_member_with_lvalue_param() {
+  static_assert(check_member_impl<T<enable_constness::const_only, is_borrowed>&>());
+  assert((check_member_impl<T<enable_constness::const_only, is_borrowed>&>()));
+  static_assert(check_member_impl<T<enable_constness::const_only, is_borrowed> const&>());
+  assert((check_member_impl<T<enable_constness::const_only, is_borrowed> const&>()));
+  static_assert(check_member_impl<T<enable_constness::both, is_borrowed>&>());
+  assert((check_member_impl<T<enable_constness::both, is_borrowed>&>()));
+  static_assert(check_member_impl<T<enable_constness::both, is_borrowed> const&>());
+  assert((check_member_impl<T<enable_constness::both, is_borrowed> const&>()));
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_member_with_rvalue_param() {
+  static_assert(check_member_impl<T<enable_constness::const_only, is_borrowed> const&&>());
+  assert((check_member_impl<T<enable_constness::const_only, is_borrowed> const&&>()));
+  static_assert(check_member_impl<T<enable_constness::both, is_borrowed> const&&>());
+  assert((check_member_impl<T<enable_constness::both, is_borrowed> const&&>()));
+}
+
+template <class T>
+[[nodiscard]] constexpr bool check_adl_impl() {
+  std::remove_cvref_t<T> t;
+  using std::begin;
+  return std::ranges::cbegin(std::forward<T>(t)) == begin(std::forward<T>(t)) && t.callee == called::adl;
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_adl_with_lvalue_param() {
+  assert((check_adl_impl<T<enable_constness::const_only, is_borrowed> const&>()));
+  assert((check_adl_impl<T<enable_constness::both, is_borrowed>&>()));
+  assert((check_adl_impl<T<enable_constness::both, is_borrowed> const&>()));
+}
+
+template <template <enable_constness, bool> class T, bool is_borrowed>
+constexpr void check_adl_with_rvalue_param() {
+  static_assert(check_adl_impl<T<enable_constness::const_only, is_borrowed> const&&>());
+  assert((check_adl_impl<T<enable_constness::const_only, is_borrowed> const&&>()));
+  static_assert(check_adl_impl<T<enable_constness::both, is_borrowed> const&&>());
+  assert((check_adl_impl<T<enable_constness::both, is_borrowed> const&&>()));
+}
+
+int main() {
+  struct S {
+    int x;
+  };
+
+  static_assert(check_lvalue_array(0, 1, 2, 3, 4, 5));
+  assert((check_lvalue_array(0, 1, 2, 3, 4, 5)));
+
+  static_assert(check_lvalue_array(0.0, 1.0));
+  assert((check_lvalue_array(0.0, 1.0)));
+
+  static_assert(check_lvalue_array(S{0}, S{1}, S{2}));
+  assert((check_lvalue_array(S{0}, S{1}, S{2})));
+
+  check_member_with_lvalue_param<member_only, !borrowed>();
+  check_member_with_lvalue_param<member_only, borrowed>();
+  check_member_with_rvalue_param<member_only, borrowed>();
+
+  check_member_with_lvalue_param<lvalue_member_only, !borrowed>();
+  check_member_with_lvalue_param<lvalue_member_only, borrowed>();
+
+  check_member_with_lvalue_param<member_preferred, !borrowed>();
+  check_member_with_lvalue_param<member_preferred, borrowed>();
+  check_member_with_rvalue_param<member_preferred, borrowed>();
+
+  check_member_with_lvalue_param<lvalue_member_preferred, !borrowed>();
+  check_member_with_lvalue_param<lvalue_member_preferred, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_only, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_only, borrowed>();
+
+  check_adl_with_lvalue_param<adl_only, !borrowed>();
+  check_adl_with_lvalue_param<adl_only, borrowed>();
+  check_adl_with_rvalue_param<adl_only, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_private_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_private_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_private_lvalue_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_private_lvalue_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_private_rvalue_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_private_rvalue_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_bad_members, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_bad_members, borrowed>();
+
+  check_adl_with_lvalue_param<lvalue_adl_with_data_member_begin, !borrowed>();
+  check_adl_with_lvalue_param<lvalue_adl_with_data_member_begin, borrowed>();
+}
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,33 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// template<class T>
+// using iterator_t = decltype(ranges::begin(declval<T&>()));
+
+#include <ranges>
+
+#include <concepts>
+
+#include "test_range.h"
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<test_range<input_iterator> >, input_iterator<int*> >);
+static_assert(std::same_as<stdr::iterator_t<test_range<input_iterator> const>, input_iterator<int const*> >);
+
+static_assert(std::same_as<stdr::iterator_t<test_non_const_range<input_iterator> >, input_iterator<int*> >);
+
+static_assert(std::same_as<stdr::iterator_t<test_common_range<input_iterator> >, input_iterator<int*> >);
+static_assert(std::same_as<stdr::iterator_t<test_common_range<input_iterator> const>, input_iterator<int const*> >);
+
+static_assert(std::same_as<stdr::iterator_t<test_non_const_common_range<input_iterator> >, input_iterator<int*> >);
diff --git a/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// match_results
+
+#include <regex>
+
+#include <concepts>
+#include <ranges>
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<std::cmatch>, std::cmatch::iterator>);
+static_assert(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
diff --git a/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// string
+
+#include <string>
+
+#include <concepts>
+#include <ranges>
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<std::string>, std::string::iterator>);
+static_assert(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
diff --git a/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// XFAIL: msvc && clang
+
+// string_view
+
+#include <string_view>
+
+#include <concepts>
+#include <ranges>
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::iterator_t<std::string_view>, std::string_view::iterator>);
+static_assert(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
diff --git a/libcxx/test/support/test_range.h b/libcxx/test/support/test_range.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/support/test_range.h
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_SUPPORT_TEST_RANGE_H
+#define LIBCXX_TEST_SUPPORT_TEST_RANGE_H
+
+#include <iterator>
+#include <ranges>
+
+#include "test_iterators.h"
+
+#ifdef _LIBCPP_HAS_NO_RANGES
+#error "test/suppoort/test_range.h" can only be included in builds supporting ranges
+#endif
+
+struct sentinel {
+  bool operator==(std::input_or_output_iterator auto) const;
+};
+
+// clang-format off
+template <template <class...> class I>
+requires std::input_or_output_iterator<I<int*> >
+struct test_range {
+  I<int*> begin();
+  I<int const*> begin() const;
+  sentinel end();
+  sentinel end() const;
+};
+
+template <template <class...> class I>
+requires std::input_or_output_iterator<I<int*> >
+struct test_non_const_range {
+  I<int*> begin();
+  sentinel end();
+};
+
+template <template <class...> class I>
+requires std::input_or_output_iterator<I<int*> >
+struct test_common_range {
+  I<int*> begin();
+  I<int const*> begin() const;
+  I<int*> end();
+  I<int*> end() const;
+};
+
+template <template <class...> class I>
+requires std::input_or_output_iterator<I<int*> >
+struct test_non_const_common_range {
+  I<int*> begin();
+  I<int*> end();
+};
+
+// clang-format on
+
+#endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H