[libc++] [ranges] SFINAE-friendly "write it three times" in views::counted.

Before this patch, the new test's `CountedInvocable<int*, int*>`
would hard-error instead of SFINAEing and cleanly returning false.

Notice that views::counted specifically does NOT work with pipes;
`counted(42)` is ill-formed. This is because `counted`'s first argument
is supposed to be an iterator, not a range.

Also, mark `views::counted(it, n)` as [[nodiscard]], and test that.
(We have a general policy now that range adaptors are consistently
marked [[nodiscard]], so that people don't accidentally think that
they have side effects. This matters mostly for `reverse` and
`transform`, arguably `drop`, and just generally let's be consistent.)

Differential Revision: https://reviews.llvm.org/D115177

Author: Quuxplusone

libcxx/include/__ranges/counted.h

@@ -9,17 +9,15 @@
 #ifndef _LIBCPP___RANGES_COUNTED_H
 #define _LIBCPP___RANGES_COUNTED_H
 
+#include <__concepts/convertible_to.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/counted_iterator.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/incrementable_traits.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 <__utility/move.h>
 #include <span>
@@ -36,50 +34,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges::views {
 
 namespace __counted {
-  template<class _From, class _To>
-  concept __explicitly_convertible = requires {
-    _To(_From{});
-  };
 
   struct __fn {
-    template<class _Iter, class _Diff>
-      requires contiguous_iterator<decay_t<_Iter>> &&
-               __explicitly_convertible<_Diff, iter_difference_t<_Iter>>
+    template<contiguous_iterator _It>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Iter&& __it, _Diff __c) const
-      noexcept(noexcept(
-        span(_VSTD::to_address(__it), static_cast<iter_difference_t<_Iter>>(__c))
-      ))
-    {
-      return span(_VSTD::to_address(__it), static_cast<iter_difference_t<_Iter>>(__c));
-    }
-
-    template<class _Iter, class _Diff>
-      requires random_access_iterator<decay_t<_Iter>> &&
-               __explicitly_convertible<_Diff, iter_difference_t<_Iter>>
+    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
+      noexcept(noexcept(span(_VSTD::to_address(__it), static_cast<size_t>(__count))))
+      // Deliberately omit return-type SFINAE, because to_address is not SFINAE-friendly
+      { return          span(_VSTD::to_address(__it), static_cast<size_t>(__count)); }
+
+    template<random_access_iterator _It>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Iter&& __it, _Diff __c) const
-      noexcept(
-        noexcept(__it + static_cast<iter_difference_t<_Iter>>(__c)) &&
-        noexcept(ranges::subrange(_VSTD::forward<_Iter>(__it), _VSTD::__decay_copy(__it)))
-      )
-    {
-      auto __last = __it + static_cast<iter_difference_t<_Iter>>(__c);
-      return ranges::subrange(_VSTD::forward<_Iter>(__it), _VSTD::move(__last));
-    }
-
-    template<class _Iter, class _Diff>
-      requires __explicitly_convertible<_Diff, iter_difference_t<_Iter>>
+    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
+      noexcept(noexcept(subrange(__it, __it + __count)))
+      -> decltype(      subrange(__it, __it + __count))
+      { return          subrange(__it, __it + __count); }
+
+    template<class _It>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Iter&& __it, _Diff __c) const
-      noexcept(noexcept(
-        ranges::subrange(counted_iterator(_VSTD::forward<_Iter>(__it), __c), default_sentinel)
-      ))
-    {
-      return ranges::subrange(counted_iterator(_VSTD::forward<_Iter>(__it), __c), default_sentinel);
-    }
+    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
+      noexcept(noexcept(subrange(counted_iterator(_VSTD::move(__it), __count), default_sentinel)))
+      -> decltype(      subrange(counted_iterator(_VSTD::move(__it), __count), default_sentinel))
+      { return          subrange(counted_iterator(_VSTD::move(__it), __count), default_sentinel); }
+
+    template<class _It, convertible_to<iter_difference_t<_It>> _Diff>
+      requires input_or_output_iterator<decay_t<_It>>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_It&& __it, _Diff&& __count) const
+      noexcept(noexcept(__go(_VSTD::forward<_It>(__it), _VSTD::forward<_Diff>(__count))))
+      -> decltype(      __go(_VSTD::forward<_It>(__it), _VSTD::forward<_Diff>(__count)))
+      { return          __go(_VSTD::forward<_It>(__it), _VSTD::forward<_Diff>(__count)); }
   };
-}
+
+} // namespace __counted
 
 inline namespace __cpo {
   inline constexpr auto counted = __counted::__fn{};

libcxx/test/libcxx/ranges/range.adaptors/range.counted/adaptor.nodiscard.verify.cpp

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// Test the libc++ extension that std::views::counted is marked as [[nodiscard]].
+
+#include <ranges>
+
+void test() {
+  int range[] = {1, 2, 3};
+
+  std::views::counted(range, 1); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}