[libc++] [ranges] Improve ranges::{begin,end,cbegin,cend,data,empty,size,ssize}

[• Quuxplusone]

Summary

This follows on from D115312, making all our CPOs follow the same pattern. In the process I found and fixed several conformance bugs (and probably fixed several more without finding them):

auto a = std::ranges::cbegin(std::string_view("x"));  // should be OK
auto b = std::ranges::cend(std::string_view("x"));  // should be OK
struct Foo { int size() &; };
int c = std::ranges::size(Foo());  // should be OK
struct Incomplete;
static_assert(not std::ranges::sized_range<Foo[]>);  // should be OK

I'm aware that the tests for all of these CPOs are bad, but I have no immediate plans to refactor them. I have added the "obviously" missing coverage for cbegin and cend, and added/corrected regression tests for the bugs mentioned above. I've also added test/libcxx/ tests for our diagnostic quality, which now is very good IMO.

If this looks good, the next step would be for me to implement the missing CPOs — cdata, rbegin, rend, crbegin, crend — along these same lines. I propose to split access.h into begin.h (begin/cbegin) and end.h (end/cend); introduce rbegin.h (rbegin/crbegin) and rend.h (rend/crend); and add cdata to the existing data.h.

[jloser]

libcxx/include/__ranges/data.h

52

Is it safe to use to_address here in trailing return type SFINAE? Remember to_address is not SFINAE-friendly as we've talked about in other PRs.

[• Quuxplusone]

"Patch application failed" in buildkite. Rebase and try again.

[• Quuxplusone]

libcxx/include/__ranges/access.h

134

Here __go is constrained with requires __class_or_enum<...>, and has a dependent return type involving ADL end. I expect this to not be ADL-proof for suitably evil inputs, because dependent-return-type-SFINAE stuff happens before constraint satisfaction (AIUI, and/or at least on Clang it seemed to).

...Yep, here's the dynamite. https://godbolt.org/z/j453na433
This case fails both before and after D115607. Here's the failure mode after:

x.cpp:4:37: error: field has incomplete type 'Incomplete'
template<class T> struct Holder { T t; };
                                    ^
__ranges/access.h:39:51: note: in instantiation of template class 'Holder<Incomplete>' requested here
    requires (_Tp __t) { { _VSTD::__decay_copy(__t.begin()) } -> input_or_output_iterator; } ||
                                                  ^
__ranges/access.h:39:28: note: in instantiation of requirement here
    requires (_Tp __t) { { _VSTD::__decay_copy(__t.begin()) } -> input_or_output_iterator; } ||
                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
__ranges/access.h:39:5: note: while substituting template arguments into constraint expression here
    requires (_Tp __t) { { _VSTD::__decay_copy(__t.begin()) } -> input_or_output_iterator; } ||

__ranges/access.h:80:16: note: while checking the satisfaction of concept '__basic_requirements<Holder<Incomplete> *&>' requested here
      requires __basic_requirements<_Tp&&> &&
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~

Since this one fails before and after, it's not a regression per se. However, it's also easy to fix using enable_if_t, as I've just proved to myself locally, so I might as well upload the fix. :)

Actually the part depicted here is also a Clang bug: https://github.com/llvm/llvm-project/issues/52643

libcxx/include/__ranges/data.h

52

Ah, this reminds me that I'm doing something in a couple places here that I didn't actually expect to work (but then it passed all the existing tests so I forgot about it).
Here __go is constrained with requires contiguous_iterator<...>, and has a dependent return type involving to_address. I expect this to not work for suitably evil inputs, because dependent-return-type-SFINAE stuff happens before constraint satisfaction (AIUI, and/or at least on Clang it seemed to).
...Yep.

static_assert(!std::invocable<decltype(std::ranges::data), std::deque<int>&>);  // now a hard error, oops

This is now fixed, too.

[• Quuxplusone]

Fix and add regression tests for the SFINAE-friendliness issues noticed by @jloser — thanks!

[• Quuxplusone]

After all that, I forgot to fix the contiguous_range<deque<int>> issue @jloser originally pointed at! Okay, now it's fixed.

[• Quuxplusone]

Re-upload to poke buildkite, now that "patch application" finally succeeded on the parent revision D115312.

[• Quuxplusone]

The GCC11 failures in https://reviews.llvm.org/harbormaster/unit/138963/ are due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101239 and I need to find workarounds. (I'm inclined to just change __t + 0 into _VSTD::__decay_copy(__t).)

[• Quuxplusone]

To be rebased after D115686 and D115838.

[• Quuxplusone]

Rebase on the new-and-smaller D115312; and also on the already-landed improvements D115838 and D115686.
This PR is still a mix of "style improvements," "diagnostic improvements," and "actual conformance issues"; I'll continue trying to extricate the conformance issues into their own PRs, probably tomorrow.

libcxx/include/__ranges/access.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_ACCESS_H
 #define _LIBCPP___RANGES_ACCESS_H
 
+#include <__concepts/class_or_enum.h>
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__utility/as_const.h>
 #include <__utility/auto_cast.h>
-#include <concepts>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
-namespace ranges {
-  template <class _Tp>
-  concept __can_borrow =
-      is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp> >;
-} // namespace ranges
-
-// [range.access.begin]
-namespace ranges::__begin {
-  template <class _Tp>
-  concept __member_begin =
-    __can_borrow<_Tp> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
-    };
+// [ranges.access.begin]
 
+namespace ranges {
+namespace __begin {
   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) {
+  concept __basic_requirements =
+    is_array_v<remove_reference_t<_Tp>> ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_cvref_t<_Tp>>;
+      __t.begin();
+      { _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
+    } ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_cvref_t<_Tp>>;
+      begin(__t);
       { _LIBCPP_AUTO_CAST(begin(__t)) } -> input_or_output_iterator;
     };
 
   struct __fn {
     template <class _Tp>
-      requires is_array_v<remove_cv_t<_Tp>>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const noexcept
-    {
-      return __t;
-    }
-
-    template <class _Tp>
-    requires __member_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      requires is_rvalue_reference_v<_Tp&&> && (!enable_borrowed_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&&, __priority_tag<3>) = delete;
+
+    template <class _Tp, enable_if_t<is_array_v<remove_reference_t<_Tp>>>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<2>)
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t)))
+      -> decltype(      _LIBCPP_AUTO_CAST(__t))
+      { return          _LIBCPP_AUTO_CAST(__t); }
+
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<1>)
       noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.begin())))
-    {
-      return _LIBCPP_AUTO_CAST(__t.begin());
-    }
-
-    template <class _Tp>
-    requires __unqualified_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      -> decltype(      _LIBCPP_AUTO_CAST(__t.begin()))
+      requires input_or_output_iterator<decltype(_LIBCPP_AUTO_CAST(__t.begin()))>
+      { return          _LIBCPP_AUTO_CAST(__t.begin()); }
+
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<0>)
       noexcept(noexcept(_LIBCPP_AUTO_CAST(begin(__t))))
-    {
-      return _LIBCPP_AUTO_CAST(begin(__t));
-    }
+      -> decltype(      _LIBCPP_AUTO_CAST(begin(__t)))
+      requires input_or_output_iterator<decltype(_LIBCPP_AUTO_CAST(begin(__t)))>
+      { return          _LIBCPP_AUTO_CAST(begin(__t)); }
 
-    void operator()(auto&&) const = delete;
+    template <class _Tp>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator()(_Tp&& __t) const
+      noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), __priority_tag<3>())))
+      requires __basic_requirements<_Tp&&> &&
+      (requires {       __go(_VSTD::forward<_Tp>(__t), __priority_tag<3>()); })
+      { return          __go(_VSTD::forward<_Tp>(__t), __priority_tag<3>()); }
   };
-} // namespace ranges::__begin
+}
 
-namespace ranges {
-  inline namespace __cpo {
-    inline constexpr auto begin = __begin::__fn{};
-  } // namespace __cpo
+} // namespace ranges
 
+namespace ranges {
   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>;
-      { _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<_Tp> >;
-    };
+// [ranges.access.end]
 
+namespace ranges {
+namespace __end {
   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>;
-      { _LIBCPP_AUTO_CAST(end(__t)) } -> sentinel_for<iterator_t<_Tp> >;
-    };
-
-  class __fn {
-  public:
-    template <class _Tp, size_t _Np>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
-      requires (sizeof(*__t) != 0)  // Disallow incomplete element types.
-    {
-      return __t + _Np;
-    }
+  concept __basic_requirements =
+    is_bounded_array_v<remove_reference_t<_Tp>> ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_reference_t<_Tp>>;
+      __t.end();
+      { _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<remove_reference_t<_Tp>>>;
+    } ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_reference_t<_Tp>>;
+      end(__t);
+      { _LIBCPP_AUTO_CAST(end(__t)) } -> sentinel_for<iterator_t<remove_reference_t<_Tp>>>;
+    };
 
+  struct __fn {
     template <class _Tp>
-    requires __member_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      requires is_rvalue_reference_v<_Tp&&> && (!enable_borrowed_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&&, __priority_tag<4>) = delete;
+
+    template <class _Tp>
+      requires is_unbounded_array_v<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&&, __priority_tag<3>) = delete;
+
+    template <class _Tp, enable_if_t<is_bounded_array_v<remove_reference_t<_Tp>>>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<2>)
+      noexcept(noexcept(__t + extent_v<remove_reference_t<_Tp>>))
+      -> decltype(      __t + extent_v<remove_reference_t<_Tp>>)
+      { return          __t + extent_v<remove_reference_t<_Tp>>; }
+
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<1>)
       noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.end())))
-    {
-      return _LIBCPP_AUTO_CAST(__t.end());
-    }
-
-    template <class _Tp>
-    requires __unqualified_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      -> decltype(      _LIBCPP_AUTO_CAST(__t.end()))
+      requires sentinel_for<decltype(_LIBCPP_AUTO_CAST(__t.end())), iterator_t<remove_reference_t<_Tp>>>
+      { return          _LIBCPP_AUTO_CAST(__t.end()); }
+
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<0>)
       noexcept(noexcept(_LIBCPP_AUTO_CAST(end(__t))))
-    {
-      return _LIBCPP_AUTO_CAST(end(__t));
-    }
+      -> decltype(      _LIBCPP_AUTO_CAST(end(__t)))
+      requires sentinel_for<decltype(_LIBCPP_AUTO_CAST(end(__t))), iterator_t<remove_reference_t<_Tp>>>
+      { return          _LIBCPP_AUTO_CAST(end(__t)); }
 
-    void operator()(auto&&) const = delete;
+    template <class _Tp>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator()(_Tp&& __t) const
+      noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), __priority_tag<4>())))
+      requires __basic_requirements<_Tp&&> &&
+      (requires {       __go(_VSTD::forward<_Tp>(__t), __priority_tag<4>()); })
+      { return          __go(_VSTD::forward<_Tp>(__t), __priority_tag<4>()); }
   };
-} // namespace ranges::__end
+}
 
-namespace ranges::inline __cpo {
+inline namespace __cpo {
   inline constexpr auto end = __end::__fn{};
-} // namespace ranges::__cpo
+} // namespace __cpo
+} // namespace ranges
 
-namespace ranges::__cbegin {
+// [range.access.cbegin]
+
+namespace ranges {
+namespace __cbegin {
   struct __fn {
     template <class _Tp>
-    requires invocable<decltype(ranges::begin), _Tp const&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const
-    noexcept(noexcept(ranges::begin(_VSTD::as_const(__t))))
-    {
-      return ranges::begin(_VSTD::as_const(__t));
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp& __t) const
+      noexcept(noexcept(ranges::begin(static_cast<const _Tp&>(__t))))
+      -> decltype(      ranges::begin(static_cast<const _Tp&>(__t)))
+      { return          ranges::begin(static_cast<const _Tp&>(__t)); }
 
     template <class _Tp>
-    requires is_rvalue_reference_v<_Tp> && invocable<decltype(ranges::begin), _Tp const&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::begin(static_cast<_Tp const&&>(__t))))
-    {
-      return ranges::begin(static_cast<_Tp const&&>(__t));
-    }
+      requires is_rvalue_reference_v<_Tp&&>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::begin(static_cast<const _Tp&&>(__t))))
+      -> decltype(      ranges::begin(static_cast<const _Tp&&>(__t)))
+      { return          ranges::begin(static_cast<const _Tp&&>(__t)); }
   };
-} // namespace ranges::__cbegin
+}
 
-namespace ranges::inline __cpo {
+inline namespace __cpo {
   inline constexpr auto cbegin = __cbegin::__fn{};
-} // namespace ranges::__cpo
+} // namespace __cpo
+} // namespace ranges
+
+// [range.access.cend]
 
-namespace ranges::__cend {
+namespace ranges {
+namespace __cend {
   struct __fn {
     template <class _Tp>
-    requires invocable<decltype(ranges::end), _Tp const&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const
-    noexcept(noexcept(ranges::end(_VSTD::as_const(__t))))
-    {
-      return ranges::end(_VSTD::as_const(__t));
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp& __t) const
+      noexcept(noexcept(ranges::end(static_cast<const _Tp&>(__t))))
+      -> decltype(      ranges::end(static_cast<const _Tp&>(__t)))
+      { return          ranges::end(static_cast<const _Tp&>(__t)); }
 
     template <class _Tp>
-    requires is_rvalue_reference_v<_Tp> && invocable<decltype(ranges::end), _Tp const&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::end(static_cast<_Tp const&&>(__t))))
-    {
-      return ranges::end(static_cast<_Tp const&&>(__t));
-    }
+      requires is_rvalue_reference_v<_Tp&&>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::end(static_cast<const _Tp&&>(__t))))
+      -> decltype(      ranges::end(static_cast<const _Tp&&>(__t)))
+      { return          ranges::end(static_cast<const _Tp&&>(__t)); }
   };
-} // namespace ranges::__cend
+}
 
-namespace ranges::inline __cpo {
+inline namespace __cpo {
   inline constexpr auto cend = __cend::__fn{};
-} // namespace ranges::__cpo
+} // namespace __cpo
+} // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_ACCESS_H

libcxx/include/__ranges/data.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_DATA_H
 #define _LIBCPP___RANGES_DATA_H
 
+#include <__concepts/class_or_enum.h>
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/iterator_traits.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/access.h>
+#include <__ranges/enable_borrowed_range.h>
 #include <__utility/forward.h>
-#include <concepts>
+#include <__utility/priority_tag.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
-namespace ranges {
 // [range.prim.data]
-namespace __data {
-  template <class _Tp>
-  concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
 
+namespace ranges {
+namespace __data {
   template <class _Tp>
-  concept __member_data =
-    requires(_Tp&& __t) {
-      { _VSTD::forward<_Tp>(__t) } -> __can_borrow;
-      { __t.data() } -> __ptr_to_object;
-    };
+  concept __basic_requirements =
+    requires (_Tp __t) {
+        requires __class_or_enum<remove_reference_t<_Tp>>;
+        __t.data();
+    } ||
+    requires (_Tp __t) { { ranges::begin(__t) } -> contiguous_iterator; };
 
+  struct __fn {
     template <class _Tp>
-  concept __ranges_begin_invocable =
-    !__member_data<_Tp> &&
-    requires(_Tp&& __t) {
-      { _VSTD::forward<_Tp>(__t) } -> __can_borrow;
-      { ranges::begin(_VSTD::forward<_Tp>(__t)) } -> contiguous_iterator;
-    };
+      requires is_rvalue_reference_v<_Tp&&> && (!enable_borrowed_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&&, __priority_tag<2>) = delete;
 
-  struct __fn {
-    template <__member_data _Tp>
-      requires __can_borrow<_Tp>
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __ptr_to_object auto operator()(_Tp&& __t) const
-        noexcept(noexcept(__t.data())) {
-      return __t.data();
-    }
+    static constexpr auto __go(_Tp&& __t, __priority_tag<1>)
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.data())))
+      -> decltype(      _LIBCPP_AUTO_CAST(__t.data()))
+      requires is_pointer_v<decltype(_LIBCPP_AUTO_CAST(declval<_Tp&>().data()))> &&
+               is_object_v<remove_pointer_t<decltype(_LIBCPP_AUTO_CAST(declval<_Tp&>().data()))>>
+      { return          _LIBCPP_AUTO_CAST(__t.data()); }
 
-    template<__ranges_begin_invocable _Tp>
-      requires __can_borrow<_Tp>
+    template <class _Tp, enable_if_t<contiguous_iterator<iterator_t<_Tp&>>>* = nullptr>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __ptr_to_object auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t))))) {
-      return _VSTD::to_address(ranges::begin(_VSTD::forward<_Tp>(__t)));
-    }
+    static constexpr auto __go(_Tp&& __t, __priority_tag<0>)
+      noexcept(noexcept(_VSTD::to_address(ranges::begin(__t))))
+      -> decltype(      _VSTD::to_address(ranges::begin(__t)))
+      { return          _VSTD::to_address(ranges::begin(__t)); }
+
+    template <class _Tp>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator()(_Tp&& __t) const
+      noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), __priority_tag<2>())))
+      requires __basic_requirements<_Tp&&> &&
+      (requires {       __go(_VSTD::forward<_Tp>(__t), __priority_tag<2>()); })
+      { return          __go(_VSTD::forward<_Tp>(__t), __priority_tag<2>()); }
   };
-} // end namespace __data
+}
 
 inline namespace __cpo {
   inline constexpr auto data = __data::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_DATA_H

libcxx/include/__ranges/empty.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_EMPTY_H
 #define _LIBCPP___RANGES_EMPTY_H
 
+#include <__concepts/class_or_enum.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__ranges/access.h>
 #include <__ranges/size.h>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
-namespace ranges {
 // [range.prim.empty]
+
+namespace ranges {
 namespace __empty {
   template <class _Tp>
-  concept __member_empty = requires(_Tp&& __t) {
+  concept __basic_requirements =
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_reference_t<_Tp>>;
       bool(__t.empty());
+    } ||
+    requires (_Tp __t) { ranges::size(__t) == 0; } ||
+    requires (_Tp __t) {
+      { ranges::begin(__t) } -> forward_iterator;
+      bool(ranges::begin(__t) == ranges::end(__t));
     };
 
-  template<class _Tp>
-  concept __can_invoke_size =
-    !__member_empty<_Tp> &&
-    requires(_Tp&& __t) { ranges::size(__t); };
+  struct __fn {
+    template <class _Tp>
+      requires is_unbounded_array_v<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&&, __priority_tag<3>) = delete;
+
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<2>)
+      noexcept(noexcept(bool(__t.empty())))
+      -> decltype(      bool(__t.empty()))
+      { return          bool(__t.empty()); }
 
     template <class _Tp>
-  concept __can_compare_begin_end =
-    !__member_empty<_Tp> &&
-    !__can_invoke_size<_Tp> &&
-    requires(_Tp&& __t) {
-      bool(ranges::begin(__t) == ranges::end(__t));
-      { ranges::begin(__t) } -> forward_iterator;
-    };
-
-  struct __fn {
-    template <__member_empty _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(bool(__t.empty()))) {
-      return bool(__t.empty());
-    }
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<1>)
+      noexcept(noexcept(ranges::size(__t) == 0))
+      -> decltype(      ranges::size(__t) == 0)
+      { return          ranges::size(__t) == 0; }
 
-    template <__can_invoke_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(ranges::size(__t))) {
-      return ranges::size(__t) == 0;
-    }
+    template <class _Tp>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<0>)
+      noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t))))
+      -> decltype(      bool(ranges::begin(__t) == ranges::end(__t)))
+      requires forward_iterator<decltype(ranges::begin(__t))>
+      { return          bool(ranges::begin(__t) == ranges::end(__t)); }
 
-    template<__can_compare_begin_end _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t)))) {
-      return ranges::begin(__t) == ranges::end(__t);
-    }
+    template <class _Tp>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator()(_Tp&& __t) const
+      noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), __priority_tag<3>())))
+      requires __basic_requirements<_Tp&&> &&
+      (requires {       __go(_VSTD::forward<_Tp>(__t), __priority_tag<3>()); })
+      { return          __go(_VSTD::forward<_Tp>(__t), __priority_tag<3>()); }
   };
 }
 
 inline namespace __cpo {
   inline constexpr auto empty = __empty::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_EMPTY_H

libcxx/include/__ranges/size.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_SIZE_H
 #define _LIBCPP___RANGES_SIZE_H
 
+#include <__concepts/class_or_enum.h>
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__utility/auto_cast.h>
-#include <concepts>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/priority_tag.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
+// [range.prim.size]
+
 namespace ranges {
+
 template<class>
 inline constexpr bool disable_sized_range = false;
 
-// [range.prim.size]
 namespace __size {
   void size(auto&) = delete;
   void size(const auto&) = delete;
 
   template <class _Tp>
-  concept __size_enabled = !disable_sized_range<remove_cvref_t<_Tp>>;
+  concept __basic_requirements =
+    is_bounded_array_v<remove_reference_t<_Tp>> ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_reference_t<_Tp>>;
+      __t.size();
+    } ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_reference_t<_Tp>>;
+      size(__t);
+    } ||
+    requires (_Tp __t) { ranges::end(__t) - ranges::begin(__t); };
 
+  struct __fn {
     template <class _Tp>
-  concept __member_size = __size_enabled<_Tp> && requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
-  };
+      requires is_unbounded_array_v<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&&, __priority_tag<4>) = delete;
 
     template <class _Tp>
-  concept __unqualified_size =
-    __size_enabled<_Tp> &&
-    !__member_size<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
-    };
+      requires is_bounded_array_v<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&&, __priority_tag<3>)
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(extent_v<remove_reference_t<_Tp>>)))
+      -> decltype(      _LIBCPP_AUTO_CAST(extent_v<remove_reference_t<_Tp>>))
+      { return          _LIBCPP_AUTO_CAST(extent_v<remove_reference_t<_Tp>>); }
+
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
+      requires (!disable_sized_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<2>)
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.size())))
+      -> decltype(      _LIBCPP_AUTO_CAST(__t.size()))
+      requires __integer_like<decltype(_LIBCPP_AUTO_CAST(__t.size()))>
+      { return          _LIBCPP_AUTO_CAST(__t.size()); }
+
+    template <class _Tp, enable_if_t<__class_or_enum<remove_reference_t<_Tp>>>* = nullptr>
+      requires __class_or_enum<remove_reference_t<_Tp>> &&
+               (!disable_sized_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<1>)
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(size(__t))))
+      -> decltype(      _LIBCPP_AUTO_CAST(size(__t)))
+      requires __integer_like<decltype(_LIBCPP_AUTO_CAST(size(__t)))>
+      { return          _LIBCPP_AUTO_CAST(size(__t)); }
+
+    template <class _Tp, class _It = decltype(ranges::begin(declval<_Tp&>()))>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<0>)
+      noexcept(noexcept(_VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))))
+      -> decltype(      _VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t)))
+      requires forward_iterator<_It> && sized_sentinel_for<decltype(ranges::end(__t)), _It>
+      { return          _VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t)); }
 
     template <class _Tp>
-  concept __difference =
-    !__member_size<_Tp> &&
-    !__unqualified_size<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp&& __t) {
-      { ranges::begin(__t) } -> forward_iterator;
-      { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(declval<_Tp>()))>;
-    };
-
-  struct __fn {
-    template <class _Tp, size_t _Sz>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
-      return _Sz;
-    }
-
-    template <class _Tp, size_t _Sz>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&)[_Sz]) const noexcept {
-      return _Sz;
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator()(_Tp&& __t) const
+      noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), __priority_tag<4>())))
+      requires __basic_requirements<_Tp&&> &&
+      (requires {       __go(_VSTD::forward<_Tp>(__t), __priority_tag<4>()); })
+      { return          __go(_VSTD::forward<_Tp>(__t), __priority_tag<4>()); }
 
-    template <__member_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.size()))) {
-      return _LIBCPP_AUTO_CAST(__t.size());
-    }
-
-    template <__unqualified_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_LIBCPP_AUTO_CAST(size(__t)))) {
-      return _LIBCPP_AUTO_CAST(size(__t));
-    }
-
-    template<__difference _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
-      return _VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
-    }
-  };
-} // end namespace __size
-
 inline namespace __cpo {
   inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
+} // namespace ranges
+
+// [range.prim.ssize]
 
+namespace ranges {
 namespace __ssize {
   struct __fn {
-    template<class _Tp>
-      requires requires (_Tp&& __t) { ranges::size(__t); }
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
-        noexcept(noexcept(ranges::size(__t))) {
-      using _Signed = make_signed_t<decltype(ranges::size(__t))>;
-      if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
+    template<class _Tp, class _Dp = make_signed_t<decltype(ranges::size(declval<_Tp&>()))>>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::size(__t)))
+      requires requires { ranges::size(__t); }
+    {
+      if constexpr (sizeof(ptrdiff_t) > sizeof(_Dp))
         return static_cast<ptrdiff_t>(ranges::size(__t));
       else
-        return static_cast<_Signed>(ranges::size(__t));
+        return static_cast<_Dp>(ranges::size(__t));
     }
   };
 }
 
 inline namespace __cpo {
   inline constexpr auto ssize = __ssize::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_SIZE_H

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::begin
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+#include <string>
+
+void nonclasstype() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_array_v<remove_reference_t<int &&> >' evaluated to false}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  std::ranges::begin(42);
+}
+
+void classtype() {
+  struct S {} s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_array_v<remove_reference_t<S &> >' evaluated to false}}
+  // expected-note@*:* {{'__t.begin()' would be invalid}}
+  // expected-note@*:* {{'begin(__t)' would be invalid}}
+  std::ranges::begin(s);
+}
+
+void baditerator() {
+  struct S { int begin(); } s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_array_v<remove_reference_t<S &> >' evaluated to false}}
+  // expected-note@*:* {{'typename decay<decltype((__t.begin()))>::type' (aka 'int') does not satisfy 'input_or_output_iterator'}}
+  // expected-note@*:* {{'begin(__t)' would be invalid}}
+  std::ranges::begin(s);
+}
+
+void rvalue() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{call to deleted function '__go'}}
+  std::ranges::begin(std::string());
+}

libcxx/test/libcxx/ranges/range.access/cbegin.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::cbegin
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+
+void f() {
+  // expected-error@*:* {{no matching function for call}}
+  std::ranges::cbegin(42);
+}

libcxx/test/libcxx/ranges/range.access/cend.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::cend
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+
+void f() {
+  // expected-error@*:* {{no matching function for call}}
+  std::ranges::cend(42);
+}

libcxx/test/libcxx/ranges/range.access/data.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::data
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+
+void f() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{'ranges::begin(__t)' would be invalid}}
+  std::ranges::data(42);
+}
+
+void g() {
+  struct S {} s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'__t.data()' would be invalid}}
+  // expected-note@*:* {{'ranges::begin(__t)' would be invalid}}
+  std::ranges::data(s);
+}

libcxx/test/libcxx/ranges/range.access/empty.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::empty
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+
+void f() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{'ranges::size(__t) == 0' would be invalid}}
+  // expected-note@*:* {{'ranges::begin(__t)' would be invalid}}
+  std::ranges::empty(42);
+}
+
+void g() {
+  struct S {} s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'bool(__t.empty())' would be invalid}}
+  // expected-note@*:* {{'ranges::size(__t) == 0' would be invalid}}
+  // expected-note@*:* {{'ranges::begin(__t)' would be invalid}}
+  std::ranges::empty(s);
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::end
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+#include <string>
+
+void nonclasstype() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_bounded_array_v<remove_reference_t<int &&> >' evaluated to false}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  std::ranges::end(42);
+}
+
+void classtype() {
+  struct S {} s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_bounded_array_v<remove_reference_t<S &> >' evaluated to false}}
+  // expected-note@*:* {{'__t.end()' would be invalid}}
+  // expected-note@*:* {{'end(__t)' would be invalid}}
+  std::ranges::end(s);
+}
+
+void baditerator() {
+  struct S { int *begin(); int end(); } s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_bounded_array_v<remove_reference_t<S &> >' evaluated to false}}
+  // expected-note@*:* {{type constraint 'sentinel_for<int, iterator_t<remove_reference_t<S &> > >' was not satisfied}}
+  // expected-note@*:* {{'end(__t)' would be invalid}}
+  std::ranges::end(s);
+}
+
+void rvalue() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{call to deleted function '__go'}}
+  std::ranges::end(std::string());
+}

libcxx/test/libcxx/ranges/range.access/size.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::size
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+
+void f() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_bounded_array_v<remove_reference_t<int &&> >' evaluated to false}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{'ranges::end(__t) - ranges::begin(__t)' would be invalid}}
+  std::ranges::size(42);
+}
+
+void g() {
+  struct S {} s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_bounded_array_v<remove_reference_t<S &> >' evaluated to false}}
+  // expected-note@*:* {{'__t.size()' would be invalid}}
+  // expected-note@*:* {{'size(__t)' would be invalid}}
+  // expected-note@*:* {{'ranges::end(__t) - ranges::begin(__t)' would be invalid}}
+  std::ranges::size(s);
+}

libcxx/test/libcxx/ranges/range.access/ssize.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::ssize
+//   Substitution failure should give reasonably nice diagnostics.
+
+#include <ranges>
+
+void f() {
+  // expected-error@*:* {{no matching function for call}}
+  std::ranges::ssize(42);
+}

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // std::ranges::begin
+// std::ranges::cbegin
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-using RangeBeginT = decltype(std::ranges::begin)&;
-using RangeCBeginT = decltype(std::ranges::cbegin)&;
+using RangeBeginT = decltype(std::ranges::begin);
+using RangeCBeginT = decltype(std::ranges::cbegin);
 
 static int globalBuff[8];
 
 static_assert(!std::is_invocable_v<RangeBeginT, int (&&)[10]>);
 static_assert( std::is_invocable_v<RangeBeginT, int (&)[10]>);
 static_assert(!std::is_invocable_v<RangeBeginT, int (&&)[]>);
 static_assert( std::is_invocable_v<RangeBeginT, int (&)[]>);
 

 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<EnabledBorrowingBeginMember> = true;
 
 constexpr bool testBeginMember() {
   BeginMember a;
   assert(std::ranges::begin(a) == &a.x);
   assert(std::ranges::cbegin(a) == &a.x);
+  static_assert(!std::is_invocable_v<RangeBeginT, BeginMember&&>);
+  static_assert(!std::is_invocable_v<RangeCBeginT, BeginMember&&>);
 
   NonConstBeginMember b;
   assert(std::ranges::begin(b) == &b.x);
+  static_assert(!std::is_invocable_v<RangeCBeginT, NonConstBeginMember&>);
 
   EnabledBorrowingBeginMember c;
+  assert(std::ranges::begin(c) == &globalBuff[0]);
+  assert(std::ranges::cbegin(c) == &globalBuff[0]);
   assert(std::ranges::begin(std::move(c)) == &globalBuff[0]);
+  assert(std::ranges::cbegin(std::move(c)) == &globalBuff[0]);
 
   BeginMemberFunction d;
   assert(std::ranges::begin(d) == &d.x);
   assert(std::ranges::cbegin(d) == &d.x);
 
   EmptyPtrBeginMember e;
   assert(std::ranges::begin(e) == &e.x);
   assert(std::ranges::cbegin(e) == &e.x);
struct BeginFunctionReturnsPtrConvertible {
   struct iterator { operator int*() const; };
   friend iterator begin(BeginFunctionReturnsPtrConvertible const&);
 };
 static_assert(!std::is_invocable_v<RangeBeginT, BeginFunctionReturnsPtrConvertible const&>);
 
 constexpr bool testBeginFunction() {
   BeginFunction a{};
   const BeginFunction aa{};
-  static_assert(!std::invocable<decltype(std::ranges::begin), decltype((a))>);
-  assert(std::ranges::begin(aa) == &aa.x);
+  static_assert(!std::invocable<RangeBeginT, decltype((a))>);
   assert(std::ranges::cbegin(a) == &a.x);
+  assert(std::ranges::begin(aa) == &aa.x);
   assert(std::ranges::cbegin(aa) == &aa.x);
 
   BeginFunctionByValue b{};
   const BeginFunctionByValue bb{};
   assert(std::ranges::begin(b) == &globalBuff[1]);
-  assert(std::ranges::begin(bb) == &globalBuff[1]);
   assert(std::ranges::cbegin(b) == &globalBuff[1]);
+  assert(std::ranges::begin(bb) == &globalBuff[1]);
   assert(std::ranges::cbegin(bb) == &globalBuff[1]);
 
   BeginFunctionEnabledBorrowing c{};
   const BeginFunctionEnabledBorrowing cc{};
   assert(std::ranges::begin(std::move(c)) == &globalBuff[2]);
-  static_assert(!std::invocable<decltype(std::ranges::cbegin), decltype(std::move(c))>);
+  assert(std::ranges::cbegin(std::move(c)) == &globalBuff[2]);
   assert(std::ranges::begin(std::move(cc)) == &globalBuff[2]);
   assert(std::ranges::cbegin(std::move(cc)) == &globalBuff[2]);
 
   BeginFunctionReturnsEmptyPtr d{};
   const BeginFunctionReturnsEmptyPtr dd{};
-  static_assert(!std::invocable<decltype(std::ranges::begin), decltype((d))>);
-  assert(std::ranges::begin(dd) == &dd.x);
+  static_assert(!std::invocable<RangeBeginT, decltype((d))>);
   assert(std::ranges::cbegin(d) == &d.x);
+  assert(std::ranges::begin(dd) == &dd.x);
   assert(std::ranges::cbegin(dd) == &dd.x);
 
   BeginFunctionWithDataMember e{};
   const BeginFunctionWithDataMember ee{};
-  static_assert(!std::invocable<decltype(std::ranges::begin), decltype((e))>);
+  static_assert(!std::invocable<RangeBeginT, decltype((e))>);
   assert(std::ranges::begin(ee) == &ee.x);
   assert(std::ranges::cbegin(e) == &e.x);
   assert(std::ranges::cbegin(ee) == &ee.x);
 
   BeginFunctionWithPrivateBeginMember f{};
   const BeginFunctionWithPrivateBeginMember ff{};
-  static_assert(!std::invocable<decltype(std::ranges::begin), decltype((f))>);
-  assert(std::ranges::begin(ff) == &ff.y);
+  static_assert(!std::invocable<RangeBeginT, decltype((f))>);
   assert(std::ranges::cbegin(f) == &f.y);
+  assert(std::ranges::begin(ff) == &ff.y);
   assert(std::ranges::cbegin(ff) == &ff.y);
 
   return true;
 }
 
 
 ASSERT_NOEXCEPT(std::ranges::begin(std::declval<int (&)[10]>()));
 ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<int (&)[10]>()));

 static_assert(!noexcept(std::ranges::cbegin(ntmbrr)));
 
 struct BeginReturnsArrayRef {
     auto begin() const noexcept -> int(&)[10];
 } brar;
 static_assert(noexcept(std::ranges::begin(brar)));
 static_assert(noexcept(std::ranges::cbegin(brar)));
 
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeBeginT, Holder<Incomplete>*>);
+static_assert(!std::is_invocable_v<RangeCBeginT, Holder<Incomplete>*>);
 
 int main(int, char**) {
   testArray();
   static_assert(testArray());
 
   testBeginMember();
   static_assert(testBeginMember());
 
   testBeginFunction();
   static_assert(testBeginFunction());
 
   return 0;
 }

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

 static_assert( std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&&>);
 
 struct BeginMemberRandomAccess {
   int buff[8];
 
   random_access_iterator<const int*> begin() const;
 };
-static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess>);
-static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess const>);
-static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess const&>);
+static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess&&>);
+static_assert(!std::is_invocable_v<RangeDataT, const BeginMemberRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeDataT, const BeginMemberRandomAccess&&>);
 
 struct BeginFriendContiguousIterator {
   int buff[8];
 
   friend constexpr ContiguousIter begin(const BeginFriendContiguousIterator &iter) {
     return ContiguousIter(iter.buff);
   }
 };
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator &>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator &&>);
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&&>);
 
 struct BeginFriendRandomAccess {
   friend random_access_iterator<const int*> begin(const BeginFriendRandomAccess iter);
 };
-static_assert(!std::is_invocable_v<RangeDataT, BeginFriendRandomAccess>);
-static_assert(!std::is_invocable_v<RangeDataT, BeginFriendRandomAccess const>);
-static_assert(!std::is_invocable_v<RangeDataT, BeginFriendRandomAccess const&>);
+static_assert(!std::is_invocable_v<RangeDataT, BeginFriendRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeDataT, BeginFriendRandomAccess&&>);
+static_assert(!std::is_invocable_v<RangeDataT, const BeginFriendRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeDataT, const BeginFriendRandomAccess&&>);
 
 struct BeginMemberRvalue {
   int buff[8];
 
   ContiguousIter begin() &&;
 };
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRvalue&&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRvalue const&>);
constexpr bool testViaRangesBegin() {
   assert(std::ranges::data(b) == b.buff);
 
   BeginMemberBorrowingEnabled c;
   assert(std::ranges::data(std::move(c)) == &globalBuff[1]);
 
   return true;
 }
 
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeDataT, Holder<Incomplete>*>);
+
+struct RandomButNotContiguous {
+  random_access_iterator<int*> begin() const;
+  random_access_iterator<int*> end() const;
+};
+static_assert(!std::is_invocable_v<RangeDataT, RandomButNotContiguous>);
+
 int main(int, char**) {
   testDataMember();
   static_assert(testDataMember());
 
   testViaRangesBegin();
   static_assert(testViaRangesBegin());
 
   return 0;
 }

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

constexpr bool testBeginEqualsEnd() {
   assert(std::ranges::empty(e) == false); // e.empty()
   assert(std::ranges::empty(std::as_const(e)) == true); // e.begin() == e.end()
 
   assert(std::ranges::empty(EvilBeginEnd()));
 
   return true;
 }
 
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeEmptyT, Holder<Incomplete>*>);
+
 int main(int, char**) {
   testEmptyMember();
   static_assert(testEmptyMember());
 
   testUsingRangesSize();
   static_assert(testUsingRangesSize());
 
   testBeginEqualsEnd();
   static_assert(testBeginEqualsEnd());
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // std::ranges::end
+// std::ranges::cend
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
-using RangeEndT = decltype(std::ranges::end)&;
-using RangeCEndT = decltype(std::ranges::cend)&;
+using RangeEndT = decltype(std::ranges::end);
+using RangeCEndT = decltype(std::ranges::cend);
 
 static int globalBuff[8];
 
 static_assert(!std::is_invocable_v<RangeEndT, int (&&)[]>);
 static_assert(!std::is_invocable_v<RangeEndT, int (&)[]>);
 static_assert(!std::is_invocable_v<RangeEndT, int (&&)[10]>);
 static_assert( std::is_invocable_v<RangeEndT, int (&)[10]>);
 

 
 constexpr bool testEndMember() {
   EndMember a;
   assert(std::ranges::end(a) == &a.x);
   assert(std::ranges::cend(a) == &a.x);
 
   NonConstEndMember b;
   assert(std::ranges::end(b) == &b.x);
+  static_assert(!std::is_invocable_v<RangeCEndT, decltype((b))>);
 
   EnabledBorrowingEndMember c;
   assert(std::ranges::end(std::move(c)) == &globalBuff[0]);
+  assert(std::ranges::cend(std::move(c)) == &globalBuff[0]);
 
   EndMemberFunction d;
   assert(std::ranges::end(d) == &d.x);
   assert(std::ranges::cend(d) == &d.x);
 
   EmptyPtrEndMember e;
   assert(std::ranges::end(e) == &e.x);
   assert(std::ranges::cend(e) == &e.x);
struct BeginMemberEndFunction {
   int x;
   constexpr const int *begin() const { return nullptr; }
   friend constexpr const int *end(BeginMemberEndFunction const& bf) { return &bf.x; }
 };
 
 constexpr bool testEndFunction() {
   const EndFunction a{};
   assert(std::ranges::end(a) == &a.x);
+  assert(std::ranges::cend(a) == &a.x);
   EndFunction aa{};
+  static_assert(!std::is_invocable_v<RangeEndT, decltype((aa))>);
   assert(std::ranges::cend(aa) == &aa.x);
 
   EndFunctionByValue b;
   assert(std::ranges::end(b) == &globalBuff[1]);
   assert(std::ranges::cend(b) == &globalBuff[1]);
 
   EndFunctionEnabledBorrowing c;
   assert(std::ranges::end(std::move(c)) == &globalBuff[2]);
+  assert(std::ranges::cend(std::move(c)) == &globalBuff[2]);
 
   const EndFunctionReturnsEmptyPtr d{};
   assert(std::ranges::end(d) == &d.x);
+  assert(std::ranges::cend(d) == &d.x);
   EndFunctionReturnsEmptyPtr dd{};
+  static_assert(!std::is_invocable_v<RangeEndT, decltype((dd))>);
   assert(std::ranges::cend(dd) == &dd.x);
 
   const EndFunctionWithDataMember e{};
   assert(std::ranges::end(e) == &e.x);
+  assert(std::ranges::cend(e) == &e.x);
   EndFunctionWithDataMember ee{};
+  static_assert(!std::is_invocable_v<RangeEndT, decltype((ee))>);
   assert(std::ranges::cend(ee) == &ee.x);
 
   const EndFunctionWithPrivateEndMember f{};
   assert(std::ranges::end(f) == &f.y);
+  assert(std::ranges::cend(f) == &f.y);
   EndFunctionWithPrivateEndMember ff{};
+  static_assert(!std::is_invocable_v<RangeEndT, decltype((ff))>);
   assert(std::ranges::cend(ff) == &ff.y);
 
   const BeginMemberEndFunction g{};
   assert(std::ranges::end(g) == &g.x);
+  assert(std::ranges::cend(g) == &g.x);
   BeginMemberEndFunction gg{};
+  static_assert(!std::is_invocable_v<RangeEndT, decltype((gg))>);
   assert(std::ranges::cend(gg) == &gg.x);
 
   return true;
 }
 
 
 ASSERT_NOEXCEPT(std::ranges::end(std::declval<int (&)[10]>()));
 ASSERT_NOEXCEPT(std::ranges::cend(std::declval<int (&)[10]>()));

 
 struct EndReturnsArrayRef {
     auto begin() const noexcept -> int(&)[10];
     auto end() const noexcept -> int(&)[10];
 } erar;
 static_assert(noexcept(std::ranges::end(erar)));
 static_assert(noexcept(std::ranges::cend(erar)));
 
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeEndT, Holder<Incomplete>*>);
+static_assert(!std::is_invocable_v<RangeCEndT, Holder<Incomplete>*>);
+
 int main(int, char**) {
   testArray();
   static_assert(testArray());
 
   testEndMember();
   static_assert(testEndMember());
 
   testEndFunction();
   static_assert(testEndFunction());
 
   return 0;
 }

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

constexpr bool testRanges() {
   ASSERT_SAME_TYPE(decltype(std::ranges::size(d)), size_t);
 
   SizeBeginAndEndMembers e;
   assert(std::ranges::size(e) == 1);
 
   return true;
 }
 
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeSizeT, Holder<Incomplete>*>);
+
 int main(int, char**) {
   testArrayType();
   static_assert(testArrayType());
 
   testHasSizeMember();
   static_assert(testHasSizeMember());
 
   testHasSizeFunction();
   static_assert(testHasSizeFunction());
 
   testRanges();
   static_assert(testRanges());
 
   return 0;
 }

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

constexpr bool test() {
   // This gets converted to ptrdiff_t because it's wider.
   ShortUnsignedReturnType c;
   assert(std::ranges::ssize(c) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(c)), ptrdiff_t);
 
   return true;
 }
 
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::is_invocable_v<RangeSSizeT, Holder<Incomplete>*>);
+
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 };
 static_assert(!std::ranges::range<iterator_begin_int_end>);
 
 struct int_begin_iterator_end {
   int begin();
   int* end();
 };
 static_assert(!std::ranges::range<int_begin_iterator_end>);
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(!std::ranges::range<Holder<Incomplete>*>);

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

 
 // template<class T>
 // concept sized_range;
 
 #include <ranges>
 
 #include "test_iterators.h"
 
-
-
 static_assert(std::ranges::sized_range<int[5]>);
 static_assert(std::ranges::sized_range<int (&)[5]>);
 static_assert(!std::ranges::sized_range<int (&)[]>);
 static_assert(!std::ranges::sized_range<int[]>);
 
+struct Incomplete;
+static_assert(!std::ranges::sized_range<Incomplete[]>);
+
 struct range_has_size {
   bidirectional_iterator<int*> begin();
   bidirectional_iterator<int*> end();
   int size();
 };
 static_assert(std::ranges::sized_range<range_has_size>);
 static_assert(!std::ranges::sized_range<range_has_size const>);