[libcxx][ranges] Add `views::counted` CPO.

[zoecarver]

Go through list of things in the docs.

[ldionne]

libcxx/include/__ranges/counted.h

40

Throughout, could you use _Iter instead of _Tp and perhaps __it instead of __t? I think it conveys the meaning a bit better.

libcxx/test/std/ranges/range.adaptors/range.counted/counted.pass.cpp

2

We need to test that views::counted is a CPO, see http://eel.is/c++draft/customization.point.object.

4

Can you add a test that views::counted(iter, diff) is SFINAEd out when diff is not convertible to the iter_difference_t of iter, per http://eel.is/c++draft/range.adaptors#range.counted-2?

30

I'm not immediately seeing why this is std::span<const int> and not std::span<int>, can you explain?

74

Can you also add a test with a forward_iterator?

[zoecarver]

libcxx/test/std/ranges/range.adaptors/range.counted/counted.pass.cpp

2

Added a test for semiregular. Are there other tests you want? Maybe noexcept tests?

74

Good idea. But I don't think forward iterator tests that much new stuff, so I added tests for cpp20_input_iterator and output_iterator.

[zoecarver]

Address Louis' comments.

[ldionne]

libcxx/include/__ranges/counted.h

43

libcxx/test/std/ranges/range.adaptors/range.counted/counted.pass.cpp

2

I think that's fine.

30

Also, can you please static_assert(std::is_same_v<decltype(std::views::counted(...)), what-you-expect>);. Otherwise, we're potentially relying on conversions between span-to-const and span-to-non-const.

Let's figure out the const situation below, because it makes little sense to my understanding.

52

Can you also add tests for contiguous_iterator<int const*>? And for all the other iterator categories below.

[zoecarver]

Apply Louis' feedback.

[ldionne]

Based on the CI failures, you've got some missing #include. Ship it once the CI is happy!

[tcanens]

libcxx/include/__ranges/counted.h

43

There are things that are implicitly-but-not-explicitly convertible to iter_difference_t<_Iter>, in which case this compiles but the wording calls for rejection.

48

Why the static_cast to the same type?

The forward is also unnecessary - the to_address overload for non-pointers should take by const& anyway.

61

For __sent shouldn't it be a move?

[• Quuxplusone]

libcxx/include/__ranges/counted.h

61

Yes, and naming-bikeshed: can we call it __last instead of __sent? __sent looks like it should be a variable of type _Sent/_Sp, not an _Iter.
IOW, seeing forward<_Iter>(__sent) was the red flag here.

Also on line 56, noexcept(ranges::subrange(_VSTD::forward<_Iter>(__it), _VSTD::__decay_copy(__it)))
or something like that. Gross. Does the standard say "expression-equivalent" so we have to get this right? or is leaving it as non-noexcept an option?

libcxx/test/std/ranges/range.adaptors/range.counted/counted.pass.cpp

30

@ldionne: The situation here is easy, unless I'm mistaken: std::views::counted((int*)iter, 8) returns a span<int>, which is implicitly convertible to span<const int>, so that's what happens.
I agree that there should be a static_assert on the actual decltype, because actually tons of types are implicitly convertible to span<const int>. Including subrange<int*,int*>, for example, which would totally not be the conforming type to return here.

[zoecarver]

Apply review comments. Fix build.

libcxx/include/__ranges/counted.h

48

Now that the second parameter is a template type parameter type I'm going to keep the static_cast.

[zoecarver]

Fix build again.

[zoecarver]

Fix the 32 bit bots.

[zoecarver]

Fix the 32 bit bots for real.

libcxx/include/CMakeLists.txt

set(files
   __node_handle
   __nullptr
   __random/uniform_int_distribution.h
   __ranges/access.h
   __ranges/all.h
   __ranges/common_view.h
   __ranges/concepts.h
   __ranges/copyable_box.h
+  __ranges/counted.h
   __ranges/dangling.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/non_propagating_cache.h

libcxx/include/__ranges/counted.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_COUNTED_H
+#define _LIBCPP___RANGES_COUNTED_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
+#include <__ranges/concepts.h>
+#include <__ranges/subrange.h>
+#include <__utility/__decay_copy.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <span>
+#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)
+
+namespace views {
+
+namespace __counted {
+  struct __fn {
+    template<class _Tp>
+      requires contiguous_iterator<decay_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t, iter_difference_t<_Tp> __c) const
+      noexcept(noexcept(
+        span(_VSTD::to_address(_VSTD::forward<_Tp>(__t)), static_cast<iter_difference_t<_Tp>>(__c))
+      ))
+    {
+      return span(_VSTD::to_address(_VSTD::forward<_Tp>(__t)), static_cast<iter_difference_t<_Tp>>(__c));
+    }
+
+    template<class _Tp>
+      requires random_access_iterator<decay_t<_Tp>>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t, iter_difference_t<_Tp> __c) const
+      noexcept(
+        noexcept(__t + static_cast<iter_difference_t<_Tp>>(__c)) &&
+        noexcept(ranges::subrange(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t)))
+      )
+    {
+      auto __sent = __t + static_cast<iter_difference_t<_Tp>>(__c);
+      return ranges::subrange(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__sent));
+    }
+
+    template<class _Tp>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t, iter_difference_t<_Tp> __c) const
+      noexcept(noexcept(
+        ranges::subrange(counted_iterator(_VSTD::forward<_Tp>(__t), __c), default_sentinel)
+      ))
+    {
+      return ranges::subrange(counted_iterator(_VSTD::forward<_Tp>(__t), __c), default_sentinel);
+    }
+  };
+}
+
+inline namespace __cpo {
+  inline constexpr auto counted = __counted::__fn{};
+} // namespace __cpo
+
+} // namespace views
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_COUNTED_H

libcxx/include/ranges

 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
+#include <__ranges/counted.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>

libcxx/test/std/ranges/range.adaptors/range.counted/counted.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::counted;
+
+#include <ranges>
+#include <span>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    {
+      contiguous_iterator<int*> iter(buffer);
+      std::span<const int> s = std::views::counted(iter, 8);
+      assert(s.size() == 8);
+      assert(s.data() == buffer);
+    }
+    {
+      const contiguous_iterator<int*> iter(buffer);
+      std::span<int> s = std::views::counted(iter, 8);
+      assert(s.size() == 8);
+      assert(s.data() == buffer);
+    }
+  }
+
+  {
+    {
+      random_access_iterator<int*> iter(buffer);
+      std::ranges::subrange<random_access_iterator<int*>> s = std::views::counted(iter, 8);
+      assert(s.size() == 8);
+      assert(s.begin() == iter);
+    }
+    {
+      const random_access_iterator<int*> iter(buffer);
+      std::ranges::subrange<random_access_iterator<int*>> s = std::views::counted(iter, 8);
+      assert(s.size() == 8);
+      assert(s.begin() == iter);
+    }
+  }
+
+  {
+    {
+      bidirectional_iterator<int*> iter(buffer);
+      std::ranges::subrange<
+        std::counted_iterator<bidirectional_iterator<int*>>,
+        std::default_sentinel_t> s = std::views::counted(iter, 8);
+      assert(s.size() == 8);
+      assert(s.begin() == std::counted_iterator(iter, 8));
+    }
+    {
+      const bidirectional_iterator<int*> iter(buffer);
+      std::ranges::subrange<
+        std::counted_iterator<bidirectional_iterator<int*>>,
+        std::default_sentinel_t> s = std::views::counted(iter, 8);
+      assert(s.size() == 8);
+      assert(s.begin() == std::counted_iterator(iter, 8));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}