[libcxx][ranges] Fix `ranges::empty` when begin, end, and empty members are provided.

[zoecarver]

Summary

Before this commit, we'd get a compilation error because the operator() overload was ambiguous.

[zoecarver]

Once the tests pass I'm going to land this.

[• Quuxplusone]

LGTM % test comments.

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

136–141

As always, please unconstexpr and unbody the functions that aren't being called.

This test has its advantages (all three functions have the same const-qualification so there's no best-match stuff to take into account) but I'd like to see additionally a test with the usual const-qualifications on getters: either

struct BeginEndEmpty2 {
  int* begin();
  int* end();
  constexpr bool empty() const { return true; }
};

or

struct BeginEndEmpty2 {
  int* begin();
  int* end();
  const int* begin() const;
  const int* end() const;
  constexpr bool empty() const { return true; }
};

which would have the advantage that you could test both std::ranges::empty(x) and std::ranges::empty(std::as_const(x)) — both should return the same result.

libcxx/include/__ranges/empty.h

namespace __empty {
 
   template<class _Tp>
   concept __can_invoke_size =
     !__member_empty<_Tp> &&
     requires(_Tp&& __t) { ranges::size(_VSTD::forward<_Tp>(__t)); };
 
   template <class _Tp>
   concept __can_compare_begin_end =
+    !__member_empty<_Tp> &&
     !__can_invoke_size<_Tp> &&
     requires(_Tp&& __t) {
       bool(ranges::begin(__t) == ranges::end(__t));
       { ranges::begin(__t) } -> forward_iterator;
     };
 
   struct __fn {
     template <__member_empty _Tp>

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

struct DisabledSizeRangeWithBeginEnd {
   friend constexpr sentinel end(DisabledSizeRangeWithBeginEnd) { return {}; }
   constexpr size_t size() const { return 1; }
 };
 
 template<>
 inline constexpr bool std::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
 static_assert(!std::is_invocable_v<RangeSizeT, DisabledSizeRangeWithBeginEnd&>);
 
+struct BeginEndAndEmpty {
+  int* begin();
+  int* end();
+  constexpr bool empty() { return true; }
+};
+
+struct BeginEndAndConstEmpty {
+  int* begin();
+  int* end();
+  constexpr bool empty() const { return true; }
+};
+
 constexpr bool testBeginEqualsEnd() {
   BeginEndNotSizedSentinel a;
   assert(std::ranges::empty(a) == true);
 
   InvalidMinusBeginEnd b;
   assert(std::ranges::empty(b) == true);
 
   IntPtrBeginAndEnd c;
   assert(std::ranges::empty(c) == false);
 
   DisabledSizeRangeWithBeginEnd d;
   assert(std::ranges::empty(d) == true);
 
+  BeginEndAndEmpty e;
+  assert(std::ranges::empty(e) == true);
+
+  BeginEndAndConstEmpty f;
+  assert(std::ranges::empty(f) == true);
+  assert(std::ranges::empty(std::as_const(f)) == true);
+
   return true;
 }
 
 int main(int, char**) {
   testEmptyMember();
   static_assert(testEmptyMember());
 
   testUsingRangesSize();
   static_assert(testUsingRangesSize());
 
   testBeginEqualsEnd();
   static_assert(testBeginEqualsEnd());
 
   return 0;
 }