[libc++] [DON'T COMMIT] Just the new tests from D115312, D115607.

[• Quuxplusone]

Summary

This is just my new test cases from D115312 and D115607. The idea is to give a blank slate so @ldionne or someone can play around with the existing CPOs and see if it's possible to make a small patch that fixes these bugs instead of my proposed big patch.

The new tests in libcxx/test/libcxx/ranges/range.access/*.verify.cpp definitely don't need to pass; they're just to illustrate a testing approach where we could test the niceness of our diagnostics in failure cases. These tests all pass after D115607, but they're merely "nice to haves," not conformance issues.

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@*:* {{does not satisfy '__class_or_enum'}}
+  // expected-note@*:* {{does not satisfy '__class_or_enum'}}
+  std::ranges::begin(42);
+}
+
+void g() {
+  struct S {} s;
+  // expected-error@*:* {{no matching function for call}}
+  // expected-note@*:* {{'is_array_v<remove_reference_t<S &> >' evaluated to false}}
+  // expected-note@*:* {{'std::__1::__decay_copy(__t.begin())' would be invalid}}
+  // expected-note@*:* {{'std::__1::__decay_copy(begin(__t))' would be invalid}}
+  std::ranges::begin(s);
+}
+
+void h() {
+  // 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@*:* {{'std::__1::__decay_copy(__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 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'}}
+  std::ranges::end(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@*:* {{'std::__1::__decay_copy(__t.end())' would be invalid}}
+  // expected-note@*:* {{'std::__1::__decay_copy(end(__t))' would be invalid}}
+  std::ranges::end(s);
+}
+
+void h() {
+  // 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@*:* {{'std::__1::__decay_copy(__t.size())' would be invalid}}
+  // expected-note@*:* {{'std::__1::__decay_copy(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/range.access.begin/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]>()));
struct NoThrowADLBegin {
   friend T begin(NoThrowADLBegin&) noexcept { return T{}; }
   friend T begin(NoThrowADLBegin const&) noexcept { return T{}; }
 };
 ASSERT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowADLBegin<int*>&>()));
 ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowADLBegin<int*>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowADLBegin<ThrowingIterator<int>>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowADLBegin<ThrowingIterator<int>>&>()));
 
+// 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/range.access.end/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 NoThrowADLEnd {
   friend T end(NoThrowADLEnd&) noexcept { return T{}; }
   friend T end(NoThrowADLEnd const&) noexcept { return T{}; }
 };
 ASSERT_NOEXCEPT(std::ranges::end(std::declval<NoThrowADLEnd<int*>&>()));
 ASSERT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowADLEnd<int*>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::end(std::declval<NoThrowADLEnd<ThrowingIterator<int>>&>()));
 ASSERT_NOT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowADLEnd<ThrowingIterator<int>>&>()));
 
+// 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/range.prim/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/range.prim/empty.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // std::ranges::empty
 
 #include <ranges>
 
 #include <cassert>
+#include <utility>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 using RangeEmptyT = decltype(std::ranges::empty);
-using RangeSizeT = decltype(std::ranges::size);
 
 static_assert(!std::is_invocable_v<RangeEmptyT, int[]>);
 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 NonConstSizeAndEmpty {
-  int size();
+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 InputRangeWithoutSize {
+    cpp17_input_iterator<int*> begin() const;
+    cpp17_input_iterator<int*> end() const;
+};
+static_assert(!std::is_invocable_v<RangeEmptyT, const InputRangeWithoutSize&>);
+
+struct NonConstEmpty {
   bool empty();
 };
-static_assert(!std::is_invocable_v<RangeSizeT, const NonConstSizeAndEmpty&>);
-static_assert(!std::is_invocable_v<RangeEmptyT, const NonConstSizeAndEmpty&>);
+static_assert(!std::is_invocable_v<RangeEmptyT, const NonConstEmpty&>);
 
 struct HasMemberAndFunction {
   constexpr bool empty() const { return true; }
   // We should never do ADL lookup for std::ranges::empty.
   friend bool empty(const HasMemberAndFunction&) { return false; }
 };
 
 struct BadReturnType {
   BadReturnType empty() { return {}; }
 };
 static_assert(!std::is_invocable_v<RangeEmptyT, BadReturnType&>);
 
 struct BoolConvertible {
-  constexpr /*TODO: explicit*/ operator bool() noexcept(false) { return true; }
+  constexpr explicit operator bool() noexcept(false) { return true; }
 };
 struct BoolConvertibleReturnType {
   constexpr BoolConvertible empty() noexcept { return {}; }
 };
 static_assert(!noexcept(std::ranges::empty(BoolConvertibleReturnType())));
 
 struct InputIterators {
   cpp17_input_iterator<int*> begin() const;
constexpr bool testBeginEqualsEnd() {
 
   DisabledSizeRangeWithBeginEnd d;
   assert(std::ranges::empty(d) == true);
 
   BeginEndAndEmpty e;
   assert(std::ranges::empty(e) == false); // e.empty()
   assert(std::ranges::empty(std::as_const(e)) == true); // e.begin() == e.end()
 
-#if 0 // TODO FIXME
   assert(std::ranges::empty(EvilBeginEnd()));
-#endif
 
   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/range.prim/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);
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/range.prim/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>);