[libcxx][ranges] Add ranges::size CPO.

[zoecarver]

Summary

The begining of [range.prim].

[zoecarver]

libcxx/include/__ranges/size.h

35

Note: phab CLI gets confused if I put multiple dependencies on a patch, so I'm just re-implementing this here and I'll remove it once D100587 lands.

59

Also note: as I understand it, integral and integer like are interchangeable for us, if this is not the case, let me know.

[cjdb]

Implementation LGTM, will look at tests soonish.

libcxx/include/__ranges/size.h

55

Thanks for making something that clears up the double negative!

73

Yeah, I don't think this one is necessary here.

78

See http://eel.is/c++draft/ranges.syn#1.

The result needs to be the iter_difference_t<_Tp>, and since I've asserted that we only care about (extended) integral types, we're clear to use make_unsigned_t<iter_difference_t<_Tp>>.

105

@tcanens mentioned in D100255 that __decay_copy isn't necessary in the actual function calls.

[zoecarver]

• Apply clarification and feedback from @cjdb.

libcxx/include/__ranges/size.h

78

Okay good to know. sized_sentinel_for requires the result to be iter_difference_t so I don't think we need to check that here. I'll add a static cast below, though.

[• Quuxplusone]

libcxx/include/__ranges/size.h

87–91

(A) I see how integral auto is mimicking https://eel.is/c++draft/range.prim.size#4 ; however, that seems to inappropriately restrict people from trying to use their own "integer-like" types, at the cost of compile-time-slowness and source-code-size. I propose that you remove the word integral from every overload here and below.

(B) Your noexcept specification fails to account for the decay-copy that happens if __t.size() returns const SomeType&. Admittedly, this is a problem only if you remove the integral constraint, because decay-copying a primitive integral type can't possibly throw.

(C) for the record: One might observe that all these conditional-noexcept-specifications violate the spirit of P0884 "Extending the noexcept Policy" and propose removing them; but @tcanens has pointed out that "expression-equivalent to" implies "has the same noexceptness as," so we are actually mandated to use (correct) noexcept-specifications throughout basically all of Ranges. (Ugh, but unavoidable.)

106

Could you explain why this =delete'd overload is necessary?
I see how it is observable ( https://godbolt.org/z/PGxzf4jGz ) and I assume it is permitted, but I don't see why it's necessary in libc++. Other implementors (GCC, MSVC) get away without it.

117

You can delete this line now. Thanks for removing this macro.

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

122–123 ↗

(On Diff #339702)

Throughout: s/Convertable/Convertible/

126 ↗

(On Diff #339702)

(A) Remove constexpr. Remove the function body. size_t size() const; is sufficient.
(B) I notice you didn't const-qualify this member; I assume it was unintentional; but this is a good place to ask, what is supposed to happen if a type has a non-const-qualified size()? What does that imply for the truthiness of sized_range<{const,} T{&,&&,}>?

192–196 ↗

(On Diff #339702)

You use assert and have a main, but this file's name is size.compile.pass.cpp.
I suppose we need yet another CI step to prevent people from putting mains in their .compile.pass.cpp tests... and probably to prevent using the identifier-token assert in those files, either.

libcxx/test/support/test_range.h

20 ↗

(On Diff #339702)

This function body should be unnecessary. If it's needed by some test, that test is wrong.
If for testing purposes we want a sentinel type that always produces an empty range, then we should name it something clearer than struct sentinel.

[cjdb]

libcxx/include/__ranges/size.h

87–91

that seems to inappropriately restrict people from trying to use their own "integer-like" types, at the cost of compile-time-slowness and source-code-size.

Only the implementation may provide integer-like types, so this is a non-concern.

102

This can be range_difference_t<remove_cvref_t<_Tp>>.

106

It provides good intrinsic documentation. @zoecarver can you please contrast the diagnostic with/without this deletion, and maybe upload them to a GitHub gist?

[zoecarver]

libcxx/include/__ranges/size.h

87–91

See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1522r1.pdf, specifically para 2.2

We do this in such a way that (a) only implementors of the Standard Library can define and use such types for now, and (b) is forward ABI compatible...

Also, this: https://reviews.llvm.org/D100080#inline-952255

---

The Standard requires that these are only integer like types, and tells us that we get to decide what that means. I think, if for no other reason than we should strive for maximum compatibility (i.e., someone shouldn't be able to write some integer type and use it in their program such that libc++ compiles and libstdc++ or msvc doesn't) we should require these types are integral. Also, I think there is an argument for correctness here.

The "compile-time-slowness and source-code-size" are extremely minimal here. The former likely can't be measured over noise.

106

This is a so called poison pill. I could be persuaded to remove it, but I think it makes the error message nicer for users. I'd like to point out that other implementations do use it.

[zoecarver]

libcxx/include/__ranges/size.h

106

@cjdb I didn't see your comments when I made mine :)

Anyway, here's a gist: https://gist.github.com/zoecarver/594015f42664e3daa7ab7c3978027682

I'm now less convinced that deleting this overload is the correct way to go.

[• Quuxplusone]

libcxx/include/__ranges/size.h

106

@zoecarver: No. The "poison pill" is the thing on lines 50-51. This is a plain old deleted overload of operator(), and GCC/MSVC seem not to use it. Check out the godbolt where the difference is observable: https://godbolt.org/z/PGxzf4jGz and compare it locally versus your implementation.

[cjdb]

libcxx/include/__ranges/size.h

106

Admittedly the deleted function is less useful in ranges::size than in ranges::begin because ranges::size accommodates all array bounded arrays, not just lvalue arrays. I support whichever provides cleaner diagnostics.

[cjdb]

libcxx/include/__ranges/size.h

83

Otherwise, if T is an array type, ranges​::​size(E) is expression-equivalent to decay-copy(extent_­v<T>).

This needs to be changed to support all bounded arrays, not just lvalue bounded arrays (especially in the wake of the deleted overload).

[zoecarver]

• Fix based on review.

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

126 ↗

(On Diff #339702)

(B) I notice you didn't const-qualify this member; I assume it was unintentional; but this is a good place to ask, what is supposed to happen if a type has a non-const-qualified size()? What does that imply for the truthiness of sized_range<{const,} T{&,&&,}>?

sized_range<const T> is true when T has a const member. It's false if the size member isn't const. That's why I actually wanted to keep this as simple as possible. It's exactly the same as SizeMember except it's disabled. I can add another one to test with a const member.

[cjdb]

Tests mostly LGTM, but I couldn't find any tests for when member size and ADL size return signed integers. It's important that signedness is preserved in both cases, so we should add tests if there aren't any.

libcxx/include/type_traits

2814 ↗

(On Diff #339809)

No longer necessary (I'd prefer it be added in a separate commit).

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

39

Please also test SizeFunctionRef and SizeFunctionRefToConst.

137–140

Users can't do this: http://eel.is/c++draft/ranges#range.sized-3.

149–154

This, however, is fine :-)

171–177

Please add a test for when the iterator isn't a forward_iterator.

[zoecarver]

• Update based on review.

[zoecarver]

BidirectionalRange -> RandomAccesslRange

[ldionne]

Overall looks great, with a few comments.

Also:

1. Is there something to update in the Ranges progress document?
2. Can we add conformance tests for the types defined in libc++? std::vector & friends.

libcxx/include/__ranges/size.h

10

_LIBCPP___RANGES_SIZE_H if we want to be consistent? I agree it's ugly as hell though, so maybe we should revisit that policy! But for now let's be consistent?

59

I think we need to introduce a proper concept for integer-like types:

template <typename _Ip>
concept __integer_like = !same_as<bool, _Ip> && integral<_Ip>;

According to the Standard:

A type I other than cv bool is integer-like if it models integral<I> or if it is an integer-class type.

That would also be an indirection point where we can add our own implementation-defined integer-class type if we have one.

Right now, my understanding is that this concept would be satisfied if t.size() returned a bool. Instead, we should use -> __integer_like so that bool is excluded. Can you confirm that it's a problem and add a test that fails when that's the case?

This comment applies to other uses of integral below (and so we should add tests for those too).

82–90

Just thinking out loud, but this works if you pass a reference to a const array because it'll deduce _Tp = Foo const such that the whole signature is Foo const (&)[_Sz]?

107–108

Would it be worth creating a __to_unsigned_like helper function that we can reuse? I don't know the spec by heart, but I imagine that if they factored out the term of art to-unsigned-like in the spec (https://eel.is/c++draft/ranges#syn-1), it must be because we're re-using it elsewhere?

111

// end namespace __size

114

Indent inside the namespace!

[cjdb]

Can we add conformance tests for the types defined in libc++? std::vector & friends.

This should be done in the sized_range patch IMO, similar to how I deferred conformance tests for D100255 to D100269.

libcxx/include/__ranges/size.h

59

Yes, but it looks like I can do this in D100080. Nice catch! http://eel.is/c++draft/iterators#iterator.concept.winc-11

[zoecarver]

libcxx/include/__ranges/size.h

59

@cjdb I agree. It would be great if you could implement __integer_like as Louis described and then implement __is_signed_integer_like in terms of that. Once __integer_like exists I'll update this patch to use it.

82–90

Yes. Added a test.

[zoecarver]

• Apply review comments.

[zoecarver]

(Sorry forgot to respond to a few comments...)

Is there something to update in the Ranges progress document?

I already marked [range.prim] as in progress/assigned to me. Once it's done I'll mark it as complete.

This should be done in the sized_range patch IMO, similar to how I deferred conformance tests for D100255 to D100269.

As usual, I don't feel strongly. I'm happy to implement this with sized_range.

[zoecarver]

libcxx/include/__ranges/size.h

59

Ping: use __integer_like after rebasing.

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

12

Add msvc and clang.

[zoecarver]

• Remove filename in header/license comment.
• Use __integer_like.
• XFAIL msvc.

[zoecarver]

• Fix includes.

[ldionne]

LGTM once you add a test with bool (to catch the change you made by using __integer_like), and CI passes.

[zoecarver]

• Add test for function/member with bool return type.

[cjdb]

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

23

Please add a test to ensure RangeSizeT is semiregular.

[zoecarver]

• Rebase.
• Add test for semiregular.

[zoecarver]

int -> short so the tests pass on 32 bit.

[• Quuxplusone]

libcxx/include/__iterator/concepts.h

142–145

It seems to me that this function belongs right below make_unsigned_t, and not right below bidirectional_iterator.

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

48

constexpr bool (and likewise throughout)
https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/

173

size_t size() const

183–186

The comment doesn't match the code. I believe you intended to write

inline constexpr bool std::disable_sized_range<const ConstSizeMemberDisabled> = true;

Also, please rename to something like s/ConstSizeMemberDisabled/ImproperlyDisabled/

196

Pass-by-const-value alert!
Either add the &, or remove the const. (Personally I'd add the &.)
https://quuxplusone.github.io/blog/2019/01/03/const-is-a-contract/
That blog post ends with some git grep lines; please run them over this and the rest of your patches and see how many other typos they catch.

213–223

Do this instead:

struct HasMinusBeginEnd {
  struct sentinel {
    friend bool operator==(sentinel, forward_iterator<int*>);
    friend constexpr long operator-(sentinel, forward_iterator<int*>) { return 2; }
    friend long operator-(forward_iterator<int*>, sentinel);
  };
  friend constexpr forward_iterator<int*> begin(HasMinusBeginEnd) { return {}; }
  friend constexpr sentinel end(HasMinusBeginEnd) { return {}; }
};

This keeps everything nicely packaged together, and also indicates (by the presence of function bodies) which functions are actually called by the test, and even (by the presence of constexpr) which functions are constexpr-called by the test.

Similarly for the other tests.

232

Should this comment s/Int/short/ or do I not understand it? What is capital-i Int in this context?

239

Is the l meaningful?

253–261

This is a good test. I'd like to see a similar one where disable_sized_range is not specialized; then my understanding is that std::ranges::size(a) would be supposed to return a.size() i.e. 1, is that right?

267

This should be std::make_unsigned_t<std::ptrdiff_t>, I believe. I don't think we should assume ptrdiff_t is invariably signed long.
Ditto throughout.
Let's test against long (or short or whatever) only when it's possible for the reader to grep back and see where that long (or short or whatever) comes from.

[zoecarver]

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

213–223

I don't want to have to define sentinel three times, so I'm going to keep it out-of-line. But I'll make the comparison operator a hidden friend.

267

struct HasMinusBeginEnd {
  friend constexpr forward_iterator<int*> begin(HasMinusBeginEnd) { return {}; }
  friend constexpr sentinel end(HasMinusBeginEnd) { return {}; }
};

constexpr long operator-(const sentinel, const forward_iterator<int*>) { return 2; }
constexpr long operator-(const forward_iterator<int*>, const sentinel) { return 2; }

So long is hardcoded in this case (as the minus operator's return type).

267

I don't think we should assume ptrdiff_t is invariably signed long.

If that assumption is ever made in this test, it will be caught by the windows and arm bots.

[zoecarver]

• Apply Arthur's comments.

[ldionne]

This still LGTM.

libcxx/include/ranges

62

Synopsis!

[• Quuxplusone]

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

213–223

Please put the sentinel in-line in the body of the class. Yes, three times.
This test should not rely on the fact that HasMinusBeginEnd::sentinel is the same type as RangeAccessRange::sentinel — those two types should be different. Making them members is the easiest way to ensure that. And also, readability for the maintainer.

You mention below that the unsigned long I thought was due to the difference_type` of forward_iterator is actually due to the return type of the operator- on line 221. This is exactly the kind of subtle detail that is best dealt with by keeping code close together and using member classes. Please do. If you don't, I'll have to do it in a separate followup commit, and I don't want to have to remember that.

[zoecarver]

• Add synopsis.
• Apply Arthur's comment.
• Fix the arm build.

libcxx/include/CMakeLists.txt

set(files
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __mutex_base
   __node_handle
   __nullptr
   __ranges/access.h
   __ranges/concepts.h
   __ranges/enable_borrowed_range.h
+  __ranges/size.h
   __split_buffer
   __sso_allocator
   __std_stream
   __string
   __threading_support
   __tree
   __tuple
   __undef_macros

libcxx/include/__iterator/concepts.h

concept bidirectional_iterator =
   derived_from<_ITER_CONCEPT<_Ip>, bidirectional_iterator_tag> &&
   requires(_Ip __i) {
     { --__i } -> same_as<_Ip&>;
     { __i-- } -> same_as<_Ip>;
   };
 
   // clang-format on
 
+template<class _From>
+[[nodiscard]] constexpr auto __to_unsigned_like(_From __x) noexcept {
+  return static_cast<make_unsigned_t<_From>>(__x);
+}
+
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_CONCEPTS_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 <__config>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/concepts.h>
+#include <__ranges/access.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+template<class>
+inline constexpr bool disable_sized_range = false;
+
+// clang-format off
+namespace ranges {
+// [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>>;
+
+  template <class _Tp>
+  concept __member_size = __size_enabled<_Tp> && requires(_Tp&& __t) {
+    { _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).size()) } -> __integer_like;
+  };
+
+  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;
+    };
+
+  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]] constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
+      return _Sz;
+    }
+
+    template <class _Tp, size_t _Sz>
+    [[nodiscard]] constexpr size_t operator()(_Tp (&)[_Sz]) const noexcept {
+      return _Sz;
+    }
+
+    template <__member_size _Tp>
+    [[nodiscard]] 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]] constexpr __integer_like auto operator()(_Tp&& __t) const
+        noexcept(noexcept(size(_VSTD::forward<_Tp>(__t)))) {
+      return size(_VSTD::forward<_Tp>(__t));
+    }
+
+    template<__difference _Tp>
+    [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
+        noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
+      return __to_unsigned_like<range_difference_t<remove_cvref_t<_Tp>>>(
+          ranges::end(__t) - ranges::begin(__t));
+    }
+  };
+} // end namespace __size
+
+inline namespace __cpo {
+  inline constexpr auto size = __size::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+// clang-format off
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_SIZE_H

libcxx/include/ranges

namespace std::ranges {
   template<class T>
     concept forward_range = see below;
 
   template<class T>
   concept bidirectional_range = see below;
 
   template <class _Tp>
     concept common_range = see below;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/enable_borrowed_range.h>
+#include <__ranges/size.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/test/std/ranges/range.access/range.prim/size.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: gcc-10
+// XFAIL: msvc && clang
+
+// std::ranges::size
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+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]>);
+
+static_assert(std::semiregular<std::remove_cv_t<RangeSizeT>>);
+
+struct SizeMember {
+  constexpr size_t size() { return 42; }
+};
+
+static_assert(!std::is_invocable_v<RangeSizeT, const SizeMember>);
+
+struct SizeFunction {
+  friend constexpr size_t size(SizeFunction) { return 42; }
+};
+
+// Make sure the size member is preferred.
+struct SizeMemberAndFunction {
+  constexpr size_t size() { return 42; }
+  friend constexpr size_t size(SizeMemberAndFunction) { return 0; }
+};
+
+bool constexpr testArrayType() {
+  int a[4];
+  int b[1];
+  SizeMember c[4];
+  SizeFunction d[4];
+
+  assert(std::ranges::size(a) == 4);
+  assert(std::ranges::size(b) == 1);
+  assert(std::ranges::size(c) == 4);
+  assert(std::ranges::size(d) == 4);
+
+  return true;
+}
+
+struct SizeMemberConst {
+  constexpr size_t size() const { return 42; }
+};
+
+struct SizeMemberSigned {
+  constexpr long size() { return 42; }
+};
+
+bool constexpr testHasSizeMember() {
+  assert(std::ranges::size(SizeMember()) == 42);
+
+  const SizeMemberConst sizeMemberConst;
+  assert(std::ranges::size(sizeMemberConst) == 42);
+
+  assert(std::ranges::size(SizeMemberAndFunction()) == 42);
+
+  assert(std::ranges::size(SizeMemberSigned()) == 42);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeMemberSigned())), long);
+
+  return true;
+}
+
+struct MoveOnlySizeFunction {
+  MoveOnlySizeFunction() = default;
+  MoveOnlySizeFunction(MoveOnlySizeFunction &&) = default;
+  MoveOnlySizeFunction(MoveOnlySizeFunction const&) = delete;
+
+  friend constexpr size_t size(MoveOnlySizeFunction) { return 42; }
+};
+
+enum EnumSizeFunction {
+  a, b
+};
+
+constexpr size_t size(EnumSizeFunction) { return 42; }
+
+struct SizeFunctionConst {
+  friend constexpr size_t size(const SizeFunctionConst) { return 42; }
+};
+
+struct SizeFunctionRef {
+  friend constexpr size_t size(SizeFunctionRef&) { return 42; }
+};
+
+struct SizeFunctionConstRef {
+  friend constexpr size_t size(SizeFunctionConstRef const&) { return 42; }
+};
+
+struct SizeFunctionSigned {
+  friend constexpr long size(SizeFunctionSigned) { return 42; }
+};
+
+bool constexpr testHasSizeFunction() {
+  assert(std::ranges::size(SizeFunction()) == 42);
+  assert(std::ranges::size(MoveOnlySizeFunction()) == 42);
+  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);
+
+  assert(std::ranges::size(SizeFunctionSigned()) == 42);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeFunctionSigned())), long);
+
+  return true;
+}
+
+struct Empty { };
+static_assert(!std::is_invocable_v<RangeSizeT, Empty>);
+
+struct InvalidReturnTypeMember {
+  Empty size();
+};
+
+struct InvalidReturnTypeFunction {
+  friend Empty size(InvalidReturnTypeFunction);
+};
+
+struct Convertible {
+  operator size_t();
+};
+
+struct ConvertibleReturnTypeMember {
+  Convertible size();
+};
+
+struct ConvertibleReturnTypeFunction {
+  friend Convertible size(ConvertibleReturnTypeFunction);
+};
+
+struct BoolReturnTypeMember {
+  bool size() const;
+};
+
+struct BoolReturnTypeFunction {
+  friend bool size(BoolReturnTypeFunction const&);
+};
+
+static_assert(!std::is_invocable_v<RangeSizeT, InvalidReturnTypeMember>);
+static_assert(!std::is_invocable_v<RangeSizeT, InvalidReturnTypeFunction>);
+static_assert( std::is_invocable_v<RangeSizeT, InvalidReturnTypeMember (&)[4]>);
+static_assert( std::is_invocable_v<RangeSizeT, InvalidReturnTypeFunction (&)[4]>);
+static_assert(!std::is_invocable_v<RangeSizeT, ConvertibleReturnTypeMember>);
+static_assert(!std::is_invocable_v<RangeSizeT, ConvertibleReturnTypeFunction>);
+static_assert(!std::is_invocable_v<RangeSizeT, BoolReturnTypeMember const&>);
+static_assert(!std::is_invocable_v<RangeSizeT, BoolReturnTypeFunction const&>);
+
+struct SizeMemberDisabled {
+  size_t size() { return 42; }
+};
+
+template<>
+inline constexpr bool std::disable_sized_range<SizeMemberDisabled> = true;
+
+struct ConstSizeMemberDisabled {
+  size_t size() const { return 42; }
+};
+
+// Intentionally disabling "const ConstSizeMemberDisabled". This doesn't disable anything
+// because T is always uncvrefed before being checked.
+template<>
+inline constexpr bool std::disable_sized_range<ConstSizeMemberDisabled> = true;
+
+struct SizeFunctionDisabled {
+  friend size_t size(SizeFunctionDisabled) { return 42; }
+};
+
+template<>
+inline constexpr bool std::disable_sized_range<SizeFunctionDisabled> = true;
+
+struct ConstSizeFunctionDisabled {
+  friend size_t size(const ConstSizeFunctionDisabled) { return 42; }
+};
+
+template<>
+inline constexpr bool std::disable_sized_range<ConstSizeFunctionDisabled> = true;
+
+static_assert(!std::is_invocable_v<RangeSizeT, SizeMemberDisabled>);
+static_assert(!std::is_invocable_v<RangeSizeT, const ConstSizeMemberDisabled>);
+static_assert(!std::is_invocable_v<RangeSizeT, SizeFunctionDisabled>);
+static_assert(!std::is_invocable_v<RangeSizeT, const ConstSizeFunctionDisabled>);
+
+// No begin end.
+struct HasMinusOperator {
+  friend constexpr size_t operator-(HasMinusOperator, HasMinusOperator) { return 2; }
+};
+static_assert(!std::is_invocable_v<RangeSizeT, HasMinusOperator>);
+
+struct sentinel {
+  bool operator==(std::input_or_output_iterator auto) const { return true; }
+};
+
+struct HasMinusBeginEnd {
+  friend constexpr forward_iterator<int*> begin(HasMinusBeginEnd) { return {}; }
+  friend constexpr sentinel end(HasMinusBeginEnd) { return {}; }
+};
+
+constexpr long operator-(const sentinel, const forward_iterator<int*>) { return 2; }
+constexpr long operator-(const forward_iterator<int*>, const sentinel) { return 2; }
+
+struct other_forward_iterator : forward_iterator<int*> { };
+
+struct InvalidMinusBeginEnd {
+  friend constexpr other_forward_iterator begin(InvalidMinusBeginEnd) { return {}; }
+  friend constexpr sentinel end(InvalidMinusBeginEnd) { return {}; }
+};
+
+// Int is integer-like, but it is not other_forward_iterator's difference_type.
+constexpr int operator-(const sentinel, const other_forward_iterator) { return 2; }
+constexpr int operator-(const other_forward_iterator, const sentinel) { return 2; }
+
+static_assert(!std::same_as<other_forward_iterator::difference_type, int>);
+static_assert(!std::is_invocable_v<RangeSizeT, InvalidMinusBeginEnd>);
+
+struct RandomAccesslRange {
+  constexpr random_access_iterator<int*> begin() { return {}; }
+  constexpr sentinel end() { return {}; }
+};
+
+constexpr long operator-(const sentinel, const random_access_iterator<int*>) { return 2; }
+constexpr long operator-(const random_access_iterator<int*>, const sentinel) { return 2; }
+
+struct IntPtrBeginAndEnd {
+  int buff[8];
+  constexpr int* begin() { return buff; }
+  constexpr int* end() { return buff + 8; }
+};
+
+struct DisabledSizeRangeWithBeginEnd {
+  int buff[8];
+  constexpr int* begin() { return buff; }
+  constexpr int* end() { return buff + 8; }
+  constexpr size_t size() { return 1; }
+};
+
+template<>
+inline constexpr bool std::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
+
+constexpr bool testRanges() {
+  HasMinusBeginEnd a;
+  assert(std::ranges::size(a) == 2);
+  // Ensure that this is converted to an *unsigned* type.
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(a)), unsigned long);
+
+  IntPtrBeginAndEnd b;
+  assert(std::ranges::size(b) == 8);
+
+  DisabledSizeRangeWithBeginEnd c;
+  assert(std::ranges::size(c) == 8);
+
+  RandomAccesslRange d;
+  assert(std::ranges::size(d) == 2);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(d)), unsigned long);
+
+  return true;
+}
+
+int main(int, char**) {
+  testArrayType();
+  static_assert(testArrayType());
+
+  testHasSizeMember();
+  static_assert(testHasSizeMember());
+
+  testHasSizeFunction();
+  static_assert(testHasSizeFunction());
+
+  testRanges();
+  static_assert(testRanges());
+
+  return 0;
+}