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

[zoecarver]

Summary

Based on D101079.

[cjdb]

libcxx/include/__ranges/size.h

103–104

invocable<__size::__fn, _Tp>?

[zoecarver]

• Use invocable
• Rebase

[ldionne]

LGTM with changes applied.

libcxx/include/__ranges/size.h

108

Here instead I would just write

require (_Tp&& __t) { ranges::size(__t); }

and get rid of __can_invoke_size. Closer to the spec and simpler IMO.

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

45

Can we move the ssize tests to their own file?

[cjdb]

LGTM with a semiregular test!

[zoecarver]

• Rebase
• Address Louis' comments

[zoecarver]

• Compute size types so they are correct on windows and 32bit.

[ldionne]

LGTM (please update synopsis).

By the way, no need to re-run CI for such minor changes. Just make the change and ship it, no need to add any more latency to the loop.

[zoecarver]

• Add synopsis.
• Rebase so the tests pass here too.

libcxx/include/__ranges/size.h

[[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
           ranges::end(__t) - ranges::begin(__t));
     }
   };
 } // end namespace __size
 
 inline namespace __cpo {
   inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
+
+namespace __ssize {
+  struct __fn {
+    template<class _Tp>
+      requires requires (_Tp&& __t) { ranges::size(__t); }
+    [[nodiscard]] constexpr integral auto operator()(_Tp&& __t) const
+        noexcept(noexcept(ranges::size(__t))) {
+      using _Signed = make_signed_t<decltype(ranges::size(__t))>;
+      if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
+        return static_cast<ptrdiff_t>(ranges::size(__t));
+      else
+        return static_cast<_Signed>(ranges::size(__t));
+    }
+  };
+}
+
+inline namespace __cpo {
+  inline constexpr const auto ssize = __ssize::__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 {
   inline namespace unspecified {
     // [range.access], range access
     inline constexpr unspecified begin = unspecified;
     inline constexpr unspecified end = unspecified;
     inline constexpr unspecified cbegin = unspecified;
     inline constexpr unspecified cend = unspecified;
 
     inline constexpr unspecified size = unspecified;
+    inline constexpr unspecified ssize = unspecified;
   }
 
   // [range.range], ranges
   template<class T>
     concept range = see below;
 
   template<class T>
     inline constexpr bool enable_borrowed_range = false;

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"
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_SAME_TYPE(decltype(std::ranges::size(a)), size_t);
   assert(std::ranges::size(b) == 1);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(b)), size_t);
   assert(std::ranges::size(c) == 4);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(c)), size_t);
   assert(std::ranges::size(d) == 4);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(d)), size_t);
 
   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);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeMember())), size_t);
 
   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);

 };
 
 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);
   assert(std::ranges::size(EnumSizeFunction()) == 42);
   assert(std::ranges::size(SizeFunctionConst()) == 42);
 
   SizeFunctionRef a;
   assert(std::ranges::size(a) == 42);
 
   const SizeFunctionConstRef b;

libcxx/test/std/ranges/range.access/range.prim/ssize.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
+
+// std::ranges::ssize
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+using RangeSSizeT = decltype(std::ranges::ssize);
+
+static_assert(!std::is_invocable_v<RangeSSizeT, int[]>);
+static_assert( std::is_invocable_v<RangeSSizeT, int[1]>);
+static_assert( std::is_invocable_v<RangeSSizeT, int (&&)[1]>);
+static_assert( std::is_invocable_v<RangeSSizeT, int (&)[1]>);
+
+static_assert(std::semiregular<std::remove_cv_t<RangeSSizeT>>);
+
+struct SizeMember {
+  constexpr size_t size() { return 42; }
+};
+
+static_assert(!std::is_invocable_v<RangeSSizeT, const SizeMember>);
+
+struct SizeFunction {
+  friend constexpr size_t size(SizeFunction) { return 42; }
+};
+
+struct SizeFunctionSigned {
+  friend constexpr std::ptrdiff_t size(SizeFunctionSigned) { return 42; }
+};
+
+struct sentinel {
+  bool operator==(std::input_or_output_iterator auto) const { return true; }
+};
+
+struct RandomAccesslRange {
+  constexpr random_access_iterator<int*> begin() { return {}; }
+  constexpr sentinel end() { return {}; }
+};
+
+constexpr std::ptrdiff_t operator-(const sentinel, const random_access_iterator<int*>) { return 2; }
+constexpr std::ptrdiff_t operator-(const random_access_iterator<int*>, const sentinel) { return 2; }
+
+struct ShortUnsignedReturnType {
+  constexpr unsigned short size() { return 42; }
+};
+
+// size_t changes depending on the platform.
+using SignedSizeT = std::make_signed_t<size_t>;
+
+constexpr bool test() {
+  int a[4];
+
+  assert(std::ranges::ssize(a) == 4);
+  ASSERT_SAME_TYPE(decltype(std::ranges::ssize(a)), SignedSizeT);
+
+  assert(std::ranges::ssize(SizeMember()) == 42);
+  ASSERT_SAME_TYPE(decltype(std::ranges::ssize(SizeMember())), SignedSizeT);
+
+  assert(std::ranges::ssize(SizeFunction()) == 42);
+  ASSERT_SAME_TYPE(decltype(std::ranges::ssize(SizeFunction())), SignedSizeT);
+
+  assert(std::ranges::ssize(SizeFunctionSigned()) == 42);
+  ASSERT_SAME_TYPE(decltype(std::ranges::ssize(SizeFunctionSigned())), std::ptrdiff_t);
+
+  RandomAccesslRange b;
+  assert(std::ranges::ssize(b) == 2);
+  ASSERT_SAME_TYPE(decltype(std::ranges::ssize(b)), std::ptrdiff_t);
+
+  // 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;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}