[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

58

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

146

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

58

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/decay_copy.h>
+#include <__utility/decay_copy.h>  // TODO: replace with auto(x) when all compilers support it
 #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)
 
-// clang-format off
+// [ranges.access.begin]
 
 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;
-    };
-
+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) { { _VSTD::__decay_copy(__t.begin()) } -> input_or_output_iterator; } ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_cvref_t<_Tp>>;
       { _VSTD::__decay_copy(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 {
-      constexpr bool __complete = __is_complete<iter_value_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.");
-      }
-    }
+      requires is_rvalue_reference_v<_Tp&&> && (!enable_borrowed_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&& __t, __priority_tag<3>) = delete;
 
     template <class _Tp>
-    requires __member_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      requires is_array_v<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<2>)
+      noexcept(noexcept(__t + 0))
+      -> decltype(      __t + 0)
+      { return          __t + 0; }
+
+    template <class _Tp>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<1>)
       noexcept(noexcept(_VSTD::__decay_copy(__t.begin())))
-    {
-      return __t.begin();
-    }
+      -> decltype(      _VSTD::__decay_copy(__t.begin()))
+      requires input_or_output_iterator<decltype(_VSTD::__decay_copy(__t.begin()))>
+      { return          _VSTD::__decay_copy(__t.begin()); }
 
     template <class _Tp>
-    requires __unqualified_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      requires __class_or_enum<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<0>)
       noexcept(noexcept(_VSTD::__decay_copy(begin(__t))))
-    {
-      return begin(__t);
-    }
+      -> decltype(      _VSTD::__decay_copy(begin(__t)))
+      requires input_or_output_iterator<decltype(_VSTD::__decay_copy(begin(__t)))>
+      { return          _VSTD::__decay_copy(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>;
-      { _VSTD::__decay_copy(_VSTD::forward<_Tp>(__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>;
-      { _VSTD::__decay_copy(end(_VSTD::forward<_Tp>(__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 {
-      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.");
-      }
-    }
+  concept __basic_requirements =
+    is_bounded_array_v<remove_reference_t<_Tp>> ||
+    requires (_Tp __t) { { _VSTD::__decay_copy(__t.end()) } -> sentinel_for<iterator_t<remove_reference_t<_Tp>>>; } ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_reference_t<_Tp>>;
+      { _VSTD::__decay_copy(end(__t)) } -> sentinel_for<iterator_t<remove_reference_t<_Tp>>>;
+    };
+
+  struct __fn {
+    template <class _Tp>
+      requires is_rvalue_reference_v<_Tp&&> && (!enable_borrowed_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&& __t, __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&& __t, __priority_tag<3>) = delete;
+
+    template <class _Tp>
+      requires is_array_v<remove_reference_t<_Tp>>
+    _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>
-    requires __member_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<1>)
       noexcept(noexcept(_VSTD::__decay_copy(__t.end())))
-    {
-      return _VSTD::forward<_Tp>(__t).end();
-    }
+      -> decltype(      _VSTD::__decay_copy(__t.end()))
+      requires sentinel_for<decltype(_VSTD::__decay_copy(__t.end())), iterator_t<remove_reference_t<_Tp>>>
+      { return          _VSTD::__decay_copy(__t.end()); }
 
     template <class _Tp>
-    requires __unqualified_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      requires __class_or_enum<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<0>)
       noexcept(noexcept(_VSTD::__decay_copy(end(__t))))
-    {
-      return end(__t);
-    }
+      -> decltype(      _VSTD::__decay_copy(end(__t)))
+      requires sentinel_for<decltype(_VSTD::__decay_copy(end(__t))), iterator_t<remove_reference_t<_Tp>>>
+      { return          _VSTD::__decay_copy(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
-
-// clang-format off
+} // 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 <__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/decay_copy.h>  // TODO: replace with auto(x) when all compilers support it
 #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)
 
-// clang-format off
-namespace ranges {
 // [range.prim.data]
+
+namespace ranges {
 namespace __data {
   template <class _Tp>
-  concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
+  concept __basic_requirements =
+    requires (_Tp __t) { _VSTD::__decay_copy(__t.data()); } ||
+    requires (_Tp __t) { { ranges::begin(__t) } -> contiguous_iterator; };
 
+  struct __fn {
     template <class _Tp>
-  concept __member_data =
-    requires(_Tp&& __t) {
-      { _VSTD::forward<_Tp>(__t) } -> __can_borrow;
-      { __t.data() } -> __ptr_to_object;
-    };
+      requires is_rvalue_reference_v<_Tp&&> && (!enable_borrowed_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&& __t, __priority_tag<2>) = delete;
 
     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;
-    };
-
-  struct __fn {
-    template <__member_data _Tp>
-      requires __can_borrow<_Tp>
     _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(_VSTD::__decay_copy(__t.data())))
+      -> decltype(      _VSTD::__decay_copy(__t.data()))
+      requires is_pointer_v<decltype(_VSTD::__decay_copy(__t.data()))> &&
+               is_object_v<remove_pointer_t<decltype(_VSTD::__decay_copy(__t.data()))>>
+      { return          _VSTD::__decay_copy(__t.data()); }
 
-    template<__ranges_begin_invocable _Tp>
-      requires __can_borrow<_Tp>
+    template <class _Tp>
     _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)))
+      requires contiguous_iterator<decltype(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
 
-// clang-format off
-
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_DATA_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/decay_copy.h>
+#include <__utility/decay_copy.h>  // TODO: replace with auto(x) when all compilers support it
+#include <__utility/declval.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)
 
-// clang-format off
+// [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) { { _VSTD::__decay_copy(__t.size()) } -> __integer_like; } ||
+    requires (_Tp __t) {
+      requires __class_or_enum<remove_reference_t<_Tp>>;
+      { _VSTD::__decay_copy(size(__t)) } -> __integer_like;
+    } ||
+    requires (_Tp __t) { ranges::end(__t) - ranges::begin(__t); };
 
+  struct __fn {
     template <class _Tp>
-  concept __member_size = __size_enabled<_Tp> && requires(_Tp&& __t) {
-    { _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).size()) } -> __integer_like;
-  };
+      requires is_unbounded_array_v<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr void __go(_Tp&& __t, __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) {
-      { _VSTD::__decay_copy(size(_VSTD::forward<_Tp>(__t))) } -> __integer_like;
-    };
+      requires is_bounded_array_v<remove_reference_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<3>)
+      noexcept(noexcept(_VSTD::__decay_copy(extent_v<remove_reference_t<_Tp>>)))
+      -> decltype(      _VSTD::__decay_copy(extent_v<remove_reference_t<_Tp>>))
+      { return          _VSTD::__decay_copy(extent_v<remove_reference_t<_Tp>>); }
 
     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;
-    }
+      requires (!disable_sized_range<remove_cvref_t<_Tp>>)
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __go(_Tp&& __t, __priority_tag<2>)
+      noexcept(noexcept(_VSTD::__decay_copy(__t.size())))
+      -> decltype(      _VSTD::__decay_copy(__t.size()))
+      requires __integer_like<decltype(_VSTD::__decay_copy(__t.size()))>
+      { return          _VSTD::__decay_copy(__t.size()); }
 
-    template <__member_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_VSTD::forward<_Tp>(__t).size())) {
-      return _VSTD::forward<_Tp>(__t).size();
-    }
-
-    template <__unqualified_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(size(_VSTD::forward<_Tp>(__t)))) {
-      return size(_VSTD::forward<_Tp>(__t));
-    }
+    template <class _Tp>
+      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(_VSTD::__decay_copy(size(__t))))
+      -> decltype(      _VSTD::__decay_copy(size(__t)))
+      requires __integer_like<decltype(_VSTD::__decay_copy(size(__t)))>
+      { return          _VSTD::__decay_copy(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<__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));
-    }
+    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>()); }
   };
-} // 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
 
-// clang-format off
-
 #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 f() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_array_v<remove_reference_t<int &&> >' evaluated to false}}
+  // expected-note@*:* {{'std::__1::__decay_copy(__t.begin())' would be invalid}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  std::ranges::begin(42);
+}
+
+void g() {
+  // 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@*:* {{'std::__1::__decay_copy(__t.data())' would be invalid}}
+  // expected-note@*:* {{'ranges::begin(__t)' would be invalid}}
+  std::ranges::data(42);
+}

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 f() {
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_bounded_array_v<remove_reference_t<int &&> >' evaluated to false}}
+  // expected-note@*:* {{'std::__1::__decay_copy(__t.end())' would be invalid}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  std::ranges::end(42);
+}
+
+void g() {
+  // 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/range.access.begin/incomplete.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
-
-// Test the libc++ specific behavior that we provide a better diagnostic when calling
-// std::ranges::begin on an array of incomplete type.
-
-#include <ranges>
-
-#include <type_traits>
-
-using begin_t = decltype(std::ranges::begin);
-
-template <class T> void f() requires std::invocable<begin_t&, T> { }
-template <class T> void f() { }
-
-void test() {
-  struct incomplete;
-  f<incomplete(&)[]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  f<incomplete(&)[10]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  f<incomplete(&)[2][2]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-
-  // This is okay because calling `std::ranges::begin` on any rvalue is ill-formed.
-  f<incomplete(&&)[10]>();
-}

libcxx/test/libcxx/ranges/range.access/range.access.cbegin/incomplete.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
-
-// Test the libc++ specific behavior that we provide a better diagnostic when calling
-// std::ranges::cbegin on an array of incomplete type.
-
-#include <ranges>
-
-#include <type_traits>
-
-using cbegin_t = decltype(std::ranges::cbegin);
-
-template <class T> void f() requires std::invocable<cbegin_t&, T> { }
-template <class T> void f() { }
-
-void test() {
-  struct incomplete;
-  f<incomplete(&)[10]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-
-  // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
-  f<incomplete(&&)[10]>();
-}

libcxx/test/libcxx/ranges/range.access/range.access.cend/incomplete.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
-
-// Test the libc++ specific behavior that we provide a better diagnostic when calling
-// std::ranges::cend on an array of incomplete type.
-
-#include <ranges>
-
-#include <type_traits>
-
-using cend_t = decltype(std::ranges::cend);
-
-template <class T> void f() requires std::invocable<cend_t&, T> { }
-template <class T> void f() { }
-
-void test() {
-  struct incomplete;
-  f<incomplete(&)[]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  f<incomplete(&)[10]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  f<incomplete(&)[2][2]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-
-  // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
-  f<incomplete(&&)[10]>();
-}

libcxx/test/libcxx/ranges/range.access/range.access.end/incomplete.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
-
-// Test the libc++ specific behavior that we provide a better diagnostic when calling
-// std::ranges::end on an array of incomplete type.
-
-#include <ranges>
-
-#include <type_traits>
-
-using end_t = decltype(std::ranges::end);
-
-template <class T> void f() requires std::invocable<end_t&, T> { }
-template <class T> void f() { }
-
-void test() {
-  struct incomplete;
-  f<incomplete(&)[]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  f<incomplete(&)[10]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  f<incomplete(&)[2][2]>();
-  // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-
-  // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
-  f<incomplete(&&)[10]>();
-}

libcxx/test/libcxx/ranges/range.access/range.prim/data.incomplete.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
-
-// Test the libc++ specific behavior that we provide a better diagnostic when calling
-// std::ranges::data on an array of incomplete type.
-
-#include <ranges>
-
-struct Incomplete;
-
-void f(Incomplete arr[]) {
-  // expected-error@*:* {{is SFINAE-unfriendly on arrays of an incomplete type.}}
-  // expected-error@*:* {{no matching function for call}}
-  std::ranges::data(arr);
-}
-
-void f(Incomplete(&arr)[]) {
-  // expected-error@*:* {{is SFINAE-unfriendly on arrays of an incomplete type.}}
-  // expected-error@*:* {{no matching function for call}}
-  std::ranges::data(arr);
-}
-
-void f(Incomplete(&&arr)[]) {
-  // expected-error@*:* {{is SFINAE-unfriendly on arrays of an incomplete type.}}
-  // expected-error@*:* {{no matching function for call}}
-  std::ranges::data(arr);
-}
-
-void f2(Incomplete arr[2]) {
-  // expected-error@*:* {{no matching function for call}}
-  std::ranges::data(arr);
-}
-
-void f(Incomplete(&arr)[2]) {
-  // expected-error@*:* {{no matching function for call}}
-  std::ranges::data(arr);
-}
-
-void f(Incomplete(&&arr)[2]) {
-  // expected-error@*:* {{no matching function for call}}
-  std::ranges::data(arr);
-}
-
-void f(Incomplete(&arr)[2][2]) {
-  // expected-error@*:* {{no matching function for call}}
-  std::ranges::data(arr);
-}

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@*:* {{'std::__1::__decay_copy(__t.size())' would be invalid}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{'ranges::end(__t) - ranges::begin(__t)' would be invalid}}
+  std::ranges::size(42);
+}

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];
 
 struct Incomplete;
 
 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 (&&)[]>);

 };
 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]>()));

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]>()));

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

 
 struct SizeFunctionSigned {
   friend constexpr long size(SizeFunctionSigned) { return 42; }
 };
 
 bool constexpr testHasSizeFunction() {
   assert(std::ranges::size(SizeFunction()) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeFunction())), size_t);
-  assert(std::ranges::size(MoveOnlySizeFunction()) == 42);
+  static_assert(!std::is_invocable_v<RangeSizeT, MoveOnlySizeFunction>);
   assert(std::ranges::size(EnumSizeFunction()) == 42);
   assert(std::ranges::size(SizeFunctionConst()) == 42);
 
   SizeFunctionRef a;
   assert(std::ranges::size(a) == 42);
 
   const SizeFunctionConstRef b;
   assert(std::ranges::size(b) == 42);

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>);