[libc++][PSTL] Fix double-move in std::transform_reduce

[h-vetinari]

Typo

libcxx/test/std/algorithms/numeric.ops/transform.reduce/pstl.transform_reduce.unary.pass.cpp

47

51

libcxx/include/__algorithm/pstl_backends/cpu_backends/transform_reduce.h

_LIBCPP_HIDE_FROM_ABI _Tp __pstl_transform_reduce(
   if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
                 __has_random_access_iterator_category<_ForwardIterator>::value) {
     return std::__terminate_on_exception([&] {
       return __par_backend::__parallel_transform_reduce(
           std::move(__first),
           std::move(__last),
           [__transform](_ForwardIterator __iter) { return __transform(*__iter); },
           std::move(__init),
-          std::move(__reduce),
+          __reduce,
           [=](_ForwardIterator __brick_first, _ForwardIterator __brick_last, _Tp __brick_init) {
             return std::__pstl_transform_reduce<__remove_parallel_policy_t<_ExecutionPolicy>>(
                 __cpu_backend_tag{},
                 std::move(__brick_first),
                 std::move(__brick_last),
                 std::move(__brick_init),
                 std::move(__reduce),
                 std::move(__transform));

libcxx/test/std/algorithms/numeric.ops/transform.reduce/pstl.transform_reduce.unary.pass.cpp

 // template<class ExecutionPolicy,
 //          class ForwardIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   T transform_reduce(ExecutionPolicy&& exec,
 //                      ForwardIterator first, ForwardIterator last,
 //                      T init, BinaryOperation binary_op, UnaryOperation unary_op);
 
 #include <numeric>
+#include <string>
 #include <vector>
 
 #include "MoveOnly.h"
 #include "test_execution_policies.h"
 #include "test_iterators.h"
 #include "test_macros.h"
 
 template <class Iter1, class ValueT>
 struct Test {
   template <class Policy>
   void operator()(Policy&& policy) {
     for (const auto& pair : {std::pair{0, 34}, {1, 35}, {2, 37}, {100, 5084}, {350, 61459}}) {
       auto [size, expected] = pair;
       std::vector<int> a(size);
       for (int i = 0; i != size; ++i)
         a[i] = i;
 
       decltype(auto) ret = std::transform_reduce(
           policy,
           Iter1(std::data(a)),
           Iter1(std::data(a) + std::size(a)),
           ValueT(34),
-          [](ValueT i, ValueT j) { return i + j; },
-          [](ValueT i) { return i + 1; });
+          [check = std::string("Banane")](ValueT i, ValueT j) {
+            assert(check == "Banane"); // ensure that no double-moves happen
+            return i + j;
+          },
+          [check = std::string("Banane")](ValueT i) {
+            assert(check == "Banane"); // ensure that no double-moves happen
+            return i + 1;
+          });
       static_assert(std::is_same_v<decltype(ret), ValueT>);
       assert(ret == expected);
     }
   }
 };
 
 int main(int, char**) {
   types::for_each(types::forward_iterator_list<int*>{}, types::apply_type_identity{[](auto v) {
                     using Iter2 = typename decltype(v)::type;
                     types::for_each(
                         types::type_list<int, MoveOnly>{},
                         TestIteratorWithPolicies<types::partial_instantiation<Test, Iter2>::template apply>{});
                   }});
 
   return 0;
 }