[libc++] [ranges] Remove the static_assert from ranges::begin and ranges::end.

[• Quuxplusone]

Summary

As discussed with ldionne. The problem with this static_assert
is that it makes ranges::begin a pitfall for anyone ever to use
inside a constraint or decltype. Many Ranges things, such as ranges::size,
are specified as "Does X if X is well-formed, or else Y if Y is well-formed,
or else `ranges::end(t) - ranges::begin(t)` if that is well-formed, or else..."
And if there's a static_assert hidden inside `ranges::begin(t)`, then you get
a hard error as soon as you ask the question -- even if the answer would have
been "no, that's not well-formed"!

Constraining on `requires { t + 0; }` or `requires { t + N; }` is verboten
because of https://gcc.gnu.org/bugzilla//show_bug.cgi?id=103700 . For ranges::begin,
we can just decay to a pointer even in the incomplete-type case. For ranges::end,
we can safely constrain on `sizeof(*t)`. Yes, this means that an array of incomplete
type has a `ranges::begin` but no `ranges::end`... just like an unbounded array of
complete type. This is a valid manifestation of IFNDR.

All of the new libcxx/test/std/ cases are mandatory behavior, as far as I'm aware.
Tests for the IFNDR cases in ranges::begin and ranges::end remain in `libcxx/test/libcxx/`.
The similar tests for ranges::empty and ranges::data were simply wrong, AFAIK.

[• Quuxplusone]

libcxx/include/__ranges/access.h

58–59

This may be a bad comment. At least it's inconsistent between "t" and "__t".

120–124

I needed to add this requires (or, I could add -> decltype(__t + _Np) if you'd rather ;)) because otherwise this hard-errors when you try to call it on an array of incomplete type.
I actually suspect that what I've got here might hit the same https://gcc.gnu.org/bugzilla//show_bug.cgi?id=103700 that I worked around in ranges::begin. If so, then I'm not sure what we should do.

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

23

This is calling ranges::data on a pointer variable. The expected-error here is surprising, but I didn't look into it.

35

If this were std::move(arr), then it would be required to SFINAE away, not hard-error. But it's not.

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

24

Every test in this file tests ranges::begin, when the test file is named empty.incomplete.verify.cpp.

[• Quuxplusone]

Indeed it was as I feared, re that GCC bug with arrays of incomplete types. https://reviews.llvm.org/harbormaster/unit/view/1587680/

I think I have the workaround now, though.

[ldionne]

I would have expected a test for SFINAE-friendliness of ranges::data on incomplete array types, but http://eel.is/c++draft/range.access#range.prim.data-2.2 says it's IFNDR. These inconsistencies in the spec are somewhat concerning.

libcxx/include/__ranges/access.h

60

Could we add another overload like this:

template <class _Tp>
      requires is_array_v<remove_cv_t<_Tp>> && !__is_complete<iter_value_t<_Tp>>
void operator()(_Tp&&) = delete;

of something of that sort? Otherwise, why don't we simply add the constraint __is_complete to this overload?

121

Why not use __is_complete? The name conveys more information than this expression IMO.

[• Quuxplusone]

libcxx/include/__ranges/access.h

60

Here, I'm intentionally permitting ranges::begin(x) to return x when x is an array of incomplete type, because that seems strictly more useful than any other behavior (and it's IFNDR so we get to pick our behavior). Notice that if the type of *x becomes complete, later in the TU, we haven't violated the ODR yet. If we did what you suggest above, and made the behavior of this function dependent on the completeness of *x, then we would be violating the ODR.

See my comment on ranges::end also; that rationale also applies here. But in the ranges::end case, we don't have the option to choose "Don't violate the ODR"; there we must simply try to minimize the collateral damage.

121

I think it's valuable for us to stay away from any named entity that might be cached by the compiler — no type trait, no concept. The only thing we have to commit to (and maybe get cached) on this line is the well-formedness of ranges::end. We don't want this to have spooky effects on the well-formedness of other unrelated things as compilation of this TU proceeds (which is what would happen if we shared a dependency on __is_complete or whatever).

[• Quuxplusone]

Remove unused helper concept __is_complete.

[ldionne]

We seem to be missing a libc++ specific test for the extension that we return the start of the array when calling ranges::begin(incomplete).

LGTM except for that nit and my other comment.

libcxx/include/__ranges/access.h

120–124

I think I'd rather use -> decltype(__t + _Np) and not acknowledge explicitly that we're treating incomplete types any special way here.

[• Quuxplusone]

libcxx/include/__ranges/access.h

120–124

My above comment dates to an earlier version of the diff. IIRC, requires requires { __t + _Np; } did indeed hit https://gcc.gnu.org/bugzilla//show_bug.cgi?id=103700 , and I believe -> decltype(__t + _Np) would also hit it. I'll upload the diff again just to make sure I'm right about that (and also I'll add the new libcxx/test/libcxx/ test you asked for). If I'm right, then I'll have to continue using requires (sizeof(*__t) != 0) here. Because of https://gcc.gnu.org/bugzilla//show_bug.cgi?id=103700 , the constraint will have to be something that doesn't depend on pointer arithmetic. (Test case from 103700 demonstrating GCC 11's problem with pointer arithmetic: https://godbolt.org/z/G7e9hx5cb )

[• Quuxplusone]

libcxx/test/libcxx/ tests.
Reintroduce decltype(__t + _Np) to prove it really doesn't work with GCC 11. Expect GCC CI to fail.

[• Quuxplusone]

libcxx/include/__ranges/access.h

120–124

Indeed I was right about that. Using

template <class _Tp, size_t _Np>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
auto operator()(_Tp (&__t)[_Np]) const noexcept
  -> decltype(__t + _Np)
{
  return __t + _Np;
}

we hit the GCC 11 bug: https://buildkite.com/llvm-project/libcxx-ci/builds/7339#e2494f74-3397-43d8-aa24-326e0275dd39
So I'm going to revert back to

template <class _Tp, size_t _Np>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
auto operator()(_Tp (&__t)[_Np]) const noexcept
  requires (sizeof(*__t) != 0)
{
  return __t + _Np;
}

, wait to confirm that CI is green again, and land this, unless @ldionne interrupts that plan. :)

[• Quuxplusone]

Revert to requires (sizeof(*__t) != 0). Will land if CI is happy with this (which I expect it will be).

[• Quuxplusone]

Grr, it turns out that GCC (due to a lower optimization setting?) is unhappy with libcxx/test/libcxx/ranges/range.access/begin.incomplete.type.pass.cpp because we want to link and run the test but it also contains undefined references to extern arrays.

https://reviews.llvm.org/harbormaster/unit/view/1756161/

[ldionne]

libcxx/include/__ranges/access.h

120–124

At least, please add a comment like // make sure _Tp is complete

[• Quuxplusone]

libcxx/include/__ranges/access.h

120–124

I feel like my super-verbose commit message should be enough... but OK, I've added a comment here.

[• Quuxplusone]

Use the TU1/TU2 approach suggested by Louis for begin.incomplete.type.pass.cpp.
Add a missing test case for ranges::begin(unbounded-array-of-complete-type), which is not IFNDR; it just has to work.

[• Quuxplusone]

Oops, rename .pass.cpp to .sh.cpp.

[• Quuxplusone]

...And remove the new test cases for ranges::begin(static_cast<int(&)[]>(a)) and so on, again. These casts are new in C++20, so they're also new in Clang 14: Clang 12 and 13 fail the new test. So, remove them so I can land this, and then we can make a new test file for these few cases after that.

libcxx/include/__ranges/access.h

 #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 {
   template <class _Tp>
   concept __can_borrow =
       is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp> >;
-
-  template<class _Tp>
-  concept __is_complete = requires { sizeof(_Tp); };
 } // namespace ranges
 
 // [range.access.begin]
 namespace ranges::__begin {
   template <class _Tp>
   concept __member_begin =
     __can_borrow<_Tp> &&
     requires(_Tp&& __t) {
       { _VSTD::__decay_copy(__t.begin()) } -> input_or_output_iterator;
     };
 
   void begin(auto&) = delete;
   void begin(const auto&) = delete;
 
   template <class _Tp>
   concept __unqualified_begin =
     !__member_begin<_Tp> &&
     __can_borrow<_Tp> &&
     __class_or_enum<remove_cvref_t<_Tp> > &&
     requires(_Tp && __t) {
       { _VSTD::__decay_copy(begin(__t)) } -> input_or_output_iterator;
     };
 
   struct __fn {
     template <class _Tp>
       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.");
-      }
+    [[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
     noexcept(noexcept(_VSTD::__decay_copy(__t.begin())))
     {
       return __t.begin();
concept __unqualified_end =
     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.");
-      }
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
+      requires (sizeof(*__t) != 0)  // Disallow incomplete element types.
+    {
 
     template <class _Tp>
     requires __member_end<_Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(_VSTD::__decay_copy(__t.end())))
     {
       return _VSTD::forward<_Tp>(__t).end();
     }
struct __fn {
     }
   };
 } // namespace ranges::__cend
 
 namespace ranges::inline __cpo {
   inline constexpr auto cend = __cend::__fn{};
 } // namespace ranges::__cpo
 
-// clang-format off
-
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_ACCESS_H

libcxx/test/libcxx/ranges/range.access/begin.incomplete_type.sh.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
+//
+//===----------------------------------------------------------------------===//
+
+// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu1.o -DTU1
+// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu2.o -DTU2
+// RUN: %{cxx} %t.tu1.o %t.tu2.o %{flags} %{link_flags} -o %t.exe
+// RUN: %{exec} %t.exe
+
+// 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 handle the IFNDR case for ranges::begin
+// by returning the beginning of the array-of-incomplete-type.
+// Use two translation units so that `Incomplete` really is never completed
+// at any point within TU2, but the array `bounded` is still given a definition
+// (in TU1) to avoid an "undefined reference" error from the linker.
+// All of the actually interesting stuff takes place within TU2.
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+#if defined(TU1)
+
+struct Incomplete {};
+Incomplete bounded[10];
+Incomplete unbounded[10];
+
+#else // defined(TU1)
+
+struct Incomplete;
+
+constexpr bool test()
+{
+    {
+    extern Incomplete bounded[10];
+    assert(std::ranges::begin(bounded) == bounded);
+    assert(std::ranges::cbegin(bounded) == bounded);
+    assert(std::ranges::begin(std::as_const(bounded)) == bounded);
+    assert(std::ranges::cbegin(std::as_const(bounded)) == bounded);
+    ASSERT_SAME_TYPE(decltype(std::ranges::begin(bounded)), Incomplete*);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cbegin(bounded)), const Incomplete*);
+    ASSERT_SAME_TYPE(decltype(std::ranges::begin(std::as_const(bounded))), const Incomplete*);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cbegin(std::as_const(bounded))), const Incomplete*);
+    }
+    {
+    extern Incomplete unbounded[];
+    assert(std::ranges::begin(unbounded) == unbounded);
+    assert(std::ranges::cbegin(unbounded) == unbounded);
+    assert(std::ranges::begin(std::as_const(unbounded)) == unbounded);
+    assert(std::ranges::cbegin(std::as_const(unbounded)) == unbounded);
+    ASSERT_SAME_TYPE(decltype(std::ranges::begin(unbounded)), Incomplete*);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cbegin(unbounded)), const Incomplete*);
+    ASSERT_SAME_TYPE(decltype(std::ranges::begin(std::as_const(unbounded))), const Incomplete*);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cbegin(std::as_const(unbounded))), const Incomplete*);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    static_assert(test());
+}
+
+#endif // defined(TU1)

libcxx/test/libcxx/ranges/range.access/end.incomplete_type.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
+
+// Test the libc++-specific behavior that we handle the IFNDR case for ranges::end
+// by being SFINAE-friendly.
+
+#include <ranges>
+#include <cassert>
+#include <type_traits>
+
+struct Incomplete;
+
+constexpr bool test()
+{
+    {
+    extern Incomplete bounded[10];
+    assert((!std::is_invocable_v<decltype(std::ranges::end), decltype((bounded))>));
+    assert((!std::is_invocable_v<decltype(std::ranges::cend), decltype((bounded))>));
+    assert((!std::is_invocable_v<decltype(std::ranges::end), decltype(std::as_const(bounded))>));
+    assert((!std::is_invocable_v<decltype(std::ranges::cend), decltype(std::as_const(bounded))>));
+    }
+    {
+    extern Incomplete unbounded[];
+    assert((!std::is_invocable_v<decltype(std::ranges::end), decltype((unbounded))>));
+    assert((!std::is_invocable_v<decltype(std::ranges::cend), decltype((unbounded))>));
+    assert((!std::is_invocable_v<decltype(std::ranges::end), decltype(std::as_const(unbounded))>));
+    assert((!std::is_invocable_v<decltype(std::ranges::cend), decltype(std::as_const(unbounded))>));
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    static_assert(test());
+}

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/range.prim/empty.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::empty 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@*:* {{call to deleted function call operator in type}}
-  // expected-error@*:* {{attempt to use a deleted function}}
-  std::ranges::begin(arr);
-}
-
-void f(Incomplete(&arr)[]) {
-  // expected-error@*:* {{is SFINAE-unfriendly on arrays of an incomplete type.}}
-  std::ranges::begin(arr);
-}
-
-void f(Incomplete(&&arr)[]) {
-  // expected-error@*:* {{is SFINAE-unfriendly on arrays of an incomplete type.}}
-  std::ranges::begin(arr);
-}
-
-void f2(Incomplete arr[2]) {
-  // expected-error@*:* {{call to deleted function call operator in type}}
-  // expected-error@*:* {{attempt to use a deleted function}}
-  std::ranges::begin(arr);
-}
-
-void f(Incomplete(&arr)[2]) {
-  std::ranges::begin(arr);
-}
-
-void f(Incomplete(&&arr)[2]) {
-  std::ranges::begin(arr);
-}
-
-void f(Incomplete(&arr)[2][2]) {
-  std::ranges::begin(arr);
-}

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

 #include "test_macros.h"
 #include "test_iterators.h"
 
 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 (&&)[]>);
 static_assert( std::is_invocable_v<RangeBeginT, int (&)[]>);
 
+struct Incomplete;
+static_assert(!std::is_invocable_v<RangeBeginT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeBeginT, Incomplete(&&)[42]>);
+static_assert(!std::is_invocable_v<RangeCBeginT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeCBeginT, Incomplete(&&)[42]>);
+
 struct BeginMember {
   int x;
   constexpr const int *begin() const { return &x; }
 };
 
 // Ensure that we can't call with rvalues with borrowing disabled.
 static_assert( std::is_invocable_v<RangeBeginT, BeginMember &>);
 static_assert(!std::is_invocable_v<RangeBeginT, BeginMember &&>);

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

 
 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]>);
 
+struct Incomplete;
+static_assert(!std::is_invocable_v<RangeEndT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeEndT, Incomplete(&&)[42]>);
+static_assert(!std::is_invocable_v<RangeCEndT, Incomplete(&&)[]>);
+static_assert(!std::is_invocable_v<RangeCEndT, Incomplete(&&)[42]>);
+
 struct EndMember {
   int x;
   constexpr const int *begin() const { return nullptr; }
   constexpr const int *end() const { return &x; }
 };
 
 // Ensure that we can't call with rvalues with borrowing disabled.
 static_assert( std::is_invocable_v<RangeEndT,  EndMember &>);

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

 static_assert(!std::is_invocable_v<RangeEmptyT, int(&)[]>);
 static_assert(!std::is_invocable_v<RangeEmptyT, int(&&)[]>);
 static_assert( std::is_invocable_v<RangeEmptyT, int[1]>);
 static_assert( std::is_invocable_v<RangeEmptyT, const int[1]>);
 static_assert( std::is_invocable_v<RangeEmptyT, int (&&)[1]>);
 static_assert( std::is_invocable_v<RangeEmptyT, int (&)[1]>);
 static_assert( std::is_invocable_v<RangeEmptyT, const int (&)[1]>);
 
+struct Incomplete;
+static_assert(!std::is_invocable_v<RangeEmptyT, Incomplete[]>);
+static_assert(!std::is_invocable_v<RangeEmptyT, Incomplete(&)[]>);
+static_assert(!std::is_invocable_v<RangeEmptyT, Incomplete(&&)[]>);
+
+extern Incomplete array_of_incomplete[42];
+static_assert(!std::ranges::empty(array_of_incomplete));
+static_assert(!std::ranges::empty(std::move(array_of_incomplete)));
+static_assert(!std::ranges::empty(std::as_const(array_of_incomplete)));
+static_assert(!std::ranges::empty(static_cast<const Incomplete(&&)[42]>(array_of_incomplete)));
+
 struct NonConstSizeAndEmpty {
   int size();
   bool empty();
 };
 static_assert(!std::is_invocable_v<RangeSizeT, const NonConstSizeAndEmpty&>);
 static_assert(!std::is_invocable_v<RangeEmptyT, const NonConstSizeAndEmpty&>);
 
 struct HasMemberAndFunction {

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

 
 using RangeSizeT = decltype(std::ranges::size);
 
 static_assert(!std::is_invocable_v<RangeSizeT, int[]>);
 static_assert( std::is_invocable_v<RangeSizeT, int[1]>);
 static_assert( std::is_invocable_v<RangeSizeT, int (&&)[1]>);
 static_assert( std::is_invocable_v<RangeSizeT, int (&)[1]>);
 
+struct Incomplete;
+static_assert(!std::is_invocable_v<RangeSizeT, Incomplete[]>);
+static_assert(!std::is_invocable_v<RangeSizeT, Incomplete(&)[]>);
+static_assert(!std::is_invocable_v<RangeSizeT, Incomplete(&&)[]>);
+
+extern Incomplete array_of_incomplete[42];
+static_assert(std::ranges::size(array_of_incomplete) == 42);
+static_assert(std::ranges::size(std::move(array_of_incomplete)) == 42);
+static_assert(std::ranges::size(std::as_const(array_of_incomplete)) == 42);
+static_assert(std::ranges::size(static_cast<const Incomplete(&&)[42]>(array_of_incomplete)) == 42);
+
 static_assert(std::semiregular<std::remove_cv_t<RangeSizeT>>);
 
 struct SizeMember {
   constexpr size_t size() { return 42; }
 };
 
 struct StaticSizeMember {
   constexpr static size_t size() { return 42; }