[libc++] Work around a Clang bug in transform_view, and regression-test.

[• Quuxplusone]

Summary

Clang trunk rejects the new test case, but this is a Clang bug (PR47414, 47509, 50864, 44833).

In module 'std' imported from /Users/aodwyer/llvm-project/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp:17:
/Users/aodwyer/llvm-project/build2/include/c++/v1/__ranges/transform_view.h:85:44: error: constraints not satisfied for alias template 'range_reference_t' [with _Rp = const NonConstView]
             regular_invocable<const _Fn&, range_reference_t<const _View>>
                                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/aodwyer/llvm-project/build2/include/c++/v1/__ranges/transform_view.h:416:25: note: in instantiation of template class 'std::ranges::transform_view<NonConstView, (lambda at /Users/aodwyer/llvm-project/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp:73:71)>' requested here
      -> decltype(      transform_view(_VSTD::forward<_Range>(__range), _VSTD::forward<_Fn>(__f)))
                        ^

We can work around this by adding a layer of indirection: put the problematic constraint into a named concept and Clang becomes more amenable to SFINAE'ing instead of hard-erroring.

Drive-by simplify range.transform/general.pass.cpp to make it clearer what it's actually testing in this area.

[ldionne]

I bet you encountered this while working on views::drop & friends? I had the same issue and I had an unfinished patch to fix this locally - thanks for finishing up and sorry for the duplicate work.

[• Quuxplusone]

Yep, or rather, my goal was to get my local Clang+libc++ to compile some training-lab-exercise code like

bool isPalindromicByAuthor(std::ranges::bidirectional_range auto&& r) {
    return std::ranges::equal(
        r | std::views::transform(&Book::author),
        r | std::views::reverse | std::views::transform(&Book::author)
    );
}
~~~
assert(isPalindromicByAuthor(shelf | std::views::drop(1)));

This bug and take/drop were basically leaves of the same tree.

libcxx/include/__ranges/transform_view.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 
+template<class _Fn, class _View>
+concept __regular_invocable_with_range_ref =
+  regular_invocable<_Fn, range_reference_t<_View>>;
+
 template<class _View, class _Fn>
 concept __transform_view_constraints =
-           view<_View> && is_object_v<_Fn> &&
-           regular_invocable<_Fn&, range_reference_t<_View>> &&
-           __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>;
 
 template<input_range _View, copy_constructible _Fn>
   requires __transform_view_constraints<_View, _Fn>
 class transform_view : public view_interface<transform_view<_View, _Fn>> {
   template<bool> class __iterator;
   template<bool> class __sentinel;
 
   [[no_unique_address]] __copyable_box<_Fn> __func_;
public:
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<false> begin() {
     return __iterator<false>{*this, ranges::begin(__base_)};
   }
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<true> begin() const
     requires range<const _View> &&
-             regular_invocable<const _Fn&, range_reference_t<const _View>>
+             __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __iterator<true>(*this, ranges::begin(__base_));
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr __sentinel<false> end() {
     return __sentinel<false>(ranges::end(__base_));
   }
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<false> end()
     requires common_range<_View>
   {
     return __iterator<false>(*this, ranges::end(__base_));
   }
   _LIBCPP_HIDE_FROM_ABI
   constexpr __sentinel<true> end() const
     requires range<const _View> &&
-             regular_invocable<const _Fn&, range_reference_t<const _View>>
+             __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __sentinel<true>(ranges::end(__base_));
   }
   _LIBCPP_HIDE_FROM_ABI
   constexpr __iterator<true> end() const
     requires common_range<const _View> &&
-             regular_invocable<const _Fn&, range_reference_t<const _View>>
+             __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __iterator<true>(*this, ranges::end(__base_));
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() requires sized_range<_View> { return ranges::size(__base_); }
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() const requires sized_range<const _View> { return ranges::size(__base_); }

libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp

 static_assert(!ValidTransformView<Range, PlusOne>);
 static_assert(!ValidTransformView<MoveOnlyView, BadFunction>);
 
 template<std::ranges::range R>
 auto toUpper(R range) {
   return std::ranges::transform_view(range, [](char c) { return std::toupper(c); });
 }
 
-unsigned badRandom() { return 42; }
-
-template<std::ranges::range R, class Fn = std::plus<std::iter_value_t<R>>>
-auto withRandom(R&& range, Fn func = Fn()) {
-  return std::ranges::transform_view(range, std::bind_front(func, badRandom()));
-}
-
 template<class E1, class E2, size_t N, class Join = std::plus<E1>>
 auto joinArrays(E1 (&a)[N], E2 (&b)[N], Join join = Join()) {
   return std::ranges::transform_view(a, [&a, &b, join](auto& x) {
     auto idx = (&x) - a;
     return join(x, b[idx]);
   });
 }
 
+struct NonConstView : std::ranges::view_base {
+  explicit NonConstView(int *b, int *e) : b_(b), e_(e) {}
+  const int *begin() { return b_; }  // deliberately non-const
+  const int *end() { return e_; }    // deliberately non-const
+  const int *b_;
+  const int *e_;
+};
+
 int main(int, char**) {
   {
-    std::vector vec = {1, 2, 3, 4};
-    auto sortOfRandom = withRandom(vec);
-    std::vector check = {43, 44, 45, 46};
-    assert(std::equal(sortOfRandom.begin(), sortOfRandom.end(), check.begin(), check.end()));
+    std::vector<int> vec = {1, 2, 3, 4};
+    auto transformed = std::ranges::transform_view(vec, [](int x) { return x + 42; });
+    int expected[] = {43, 44, 45, 46};
+    assert(std::equal(transformed.begin(), transformed.end(), expected, expected + 4));
+    const auto& ct = transformed;
+    assert(std::equal(ct.begin(), ct.end(), expected, expected + 4));
+  }
+
+  {
+    // Test a view type that is not const-iterable.
+    int a[] = {1, 2, 3, 4};
+    auto transformed = NonConstView(a, a + 4) | std::views::transform([](int x) { return x + 42; });
+    int expected[4] = {43, 44, 45, 46};
+    assert(std::equal(transformed.begin(), transformed.end(), expected, expected + 4));
   }
 
   {
     int a[4] = {1, 2, 3, 4};
     int b[4] = {4, 3, 2, 1};
     auto out = joinArrays(a, b);
     int check[4] = {5, 5, 5, 5};
-    assert(std::equal(out.begin(), out.end(), check));
+    assert(std::equal(out.begin(), out.end(), check, check + 4));
   }
 
   {
     std::string_view str = "Hello, World.";
     auto upp = toUpper(str);
     std::string_view check = "HELLO, WORLD.";
     assert(std::equal(upp.begin(), upp.end(), check.begin(), check.end()));
   }
 
   return 0;
 }