Changed more std::move calls to _Ops::__iter_move

libcxx/include/__algorithm/sort.h

_LIBCPP_HIDDEN unsigned __sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
   return __r;
 }
 
 template <class _AlgPolicy, class _Compare, class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI unsigned __sort5_wrap_policy(
     _ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, _ForwardIterator __x4, _ForwardIterator __x5,
     _Compare __c) {
   using _WrappedComp = typename _WrapAlgPolicy<_AlgPolicy, _Compare>::type;
-  using _Ops = _IterOps<_AlgPolicy>;
   _WrappedComp __wrapped_comp(__c);
-  return std::__sort5<_WrappedComp>(
-      _Ops::__iter_move(__x1), _Ops::__iter_move(__x2), _Ops::__iter_move(__x3), _Ops::__iter_move(__x4), _Ops::__iter_move(__x5), __wrapped_comp);
+  return std::__sort5<_WrappedComp, _ForwardIterator>(
+      std::move(__x1), std::move(__x2), std::move(__x3), std::move(__x4), std::move(__x5), __wrapped_comp);
 }
 
 // The comparator being simple is a prerequisite for using the branchless optimization.
 template <class _Tp>
 struct __is_simple_comparator : false_type {};
 template <class _Tp>
 struct __is_simple_comparator<__less<_Tp>&> : true_type {};
 template <class _Tp>

 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
 inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
 __sort4_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
                          _RandomAccessIterator __x4, _Compare __c) {
   std::__sort4<_AlgPolicy, _Compare>(__x1, __x2, __x3, __x4, __c);
 }
 
-template <class, class _Compare, class _RandomAccessIterator>
+template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
 inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
 __sort5_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
                          _RandomAccessIterator __x4, _RandomAccessIterator __x5, _Compare __c) {
   std::__cond_swap<_Compare>(__x1, __x2, __c);
   std::__cond_swap<_Compare>(__x4, __x5, __c);
   std::__partially_sorted_swap<_Compare>(__x3, __x4, __x5, __c);
   std::__cond_swap<_Compare>(__x2, __x5, __c);
   std::__partially_sorted_swap<_Compare>(__x1, __x3, __x4, __c);
_LIBCPP_HIDDEN bool __insertion_sort_incomplete(
 
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   switch (__last - __first) {
   case 0:
   case 1:
     return true;
   case 2:
     if (__comp(*--__last, *__first))
-      _IterOps<_AlgPolicy>::iter_swap(__first, __last);
+      _Ops::iter_swap(__first, __last);
     return true;
   case 3:
     std::__sort3_maybe_branchless<_AlgPolicy, _Compare>(__first, __first + difference_type(1), --__last, __comp);
     return true;
   case 4:
     std::__sort4_maybe_branchless<_AlgPolicy, _Compare>(
         __first, __first + difference_type(1), __first + difference_type(2), --__last, __comp);
     return true;
for (++__last2; ++__first1 != __last1; ++__last2) {
       value_type* __i2 = __j2;
       if (__comp(*__first1, *--__i2)) {
         ::new ((void*)__j2) value_type(std::move(*__i2));
         __d.template __incr<value_type>();
         for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2)
           *__j2 = std::move(*__i2);
         *__j2 = _Ops::__iter_move(__first1);
       } else {
-        ::new ((void*)__j2) value_type(_Ops::_iter_move(__first1));
+        ::new ((void*)__j2) value_type(_Ops::__iter_move(__first1));
         __d.template __incr<value_type>();
       }
     }
     __h.release();
   }
 }
 
-template <class _RandomAccessIterator>
+template <class _AlgPolicy, class _RandomAccessIterator>
 inline _LIBCPP_HIDE_FROM_ABI void __swap_bitmap_pos(_RandomAccessIterator __first, _RandomAccessIterator __last,
                                                     uint64_t& __left_bitset, uint64_t& __right_bitset) {
+  using _Ops = _IterOps<_AlgPolicy>;
   typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   // Swap one pair on each iteration as long as both bitsets have at least one
   // element for swapping.
   while (__left_bitset != 0 && __right_bitset != 0) {
     difference_type tz_left = __libcpp_ctz(__left_bitset);
     __left_bitset = __libcpp_blsr(__left_bitset);
     difference_type tz_right = __libcpp_ctz(__right_bitset);
     __right_bitset = __libcpp_blsr(__right_bitset);
-    std::iter_swap(__first + tz_left, __last - tz_right);
+    _Ops::iter_swap(__first + tz_left, __last - tz_right);
   }
 }
 
 template <class _Compare, class _RandomAccessIterator,
           class _ValueType = typename iterator_traits<_RandomAccessIterator>::value_type>
 inline _LIBCPP_HIDE_FROM_ABI void __populate_left_bitset(_RandomAccessIterator __first, _Compare __comp,
                                                          _ValueType& __pivot, uint64_t& __left_bitset) {
   // Possible vectorization. With a proper "-march" flag, the following loop
inline _LIBCPP_HIDE_FROM_ABI void __populate_right_bitset(_RandomAccessIterator __lm1, _Compare __comp,
   for (int __j = 0; __j < __detail::__block_size;) {
     bool __comp_result = __comp(*__iter, __pivot);
     __right_bitset |= (static_cast<uint64_t>(__comp_result) << __j);
     __j++;
     --__iter;
   }
 }
 
-template <class _Compare, class _RandomAccessIterator,
+template <class _AlgPolicy, class _Compare, class _RandomAccessIterator,
           class _ValueType = typename iterator_traits<_RandomAccessIterator>::value_type>
 inline _LIBCPP_HIDE_FROM_ABI void
 __bitset_partition_partial_blocks(_RandomAccessIterator& __first, _RandomAccessIterator& __lm1, _Compare __comp,
                                   _ValueType& __pivot, uint64_t& __left_bitset, uint64_t& __right_bitset) {
   typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   difference_type __remaining_len = __lm1 - __first + 1;
   difference_type __l_size;
   difference_type __r_size;
__bitset_partition_partial_blocks(_RandomAccessIterator& __first, _RandomAccessIterator& __lm1, _Compare __comp,
   if (__right_bitset == 0) {
     _RandomAccessIterator __iter = __lm1;
     for (int j = 0; j < __r_size; j++) {
       bool __comp_result = __comp(*__iter, __pivot);
       __right_bitset |= (static_cast<uint64_t>(__comp_result) << j);
       --__iter;
     }
   }
-  __swap_bitmap_pos(__first, __lm1, __left_bitset, __right_bitset);
+  __swap_bitmap_pos<_AlgPolicy, _RandomAccessIterator>(__first, __lm1, __left_bitset, __right_bitset);
   __first += (__left_bitset == 0) ? __l_size : 0;
   __lm1 -= (__right_bitset == 0) ? __r_size : 0;
 }
 
-template <class _RandomAccessIterator>
+template <class _AlgPolicy, class _RandomAccessIterator>
 inline _LIBCPP_HIDE_FROM_ABI void __swap_bitmap_pos_within(_RandomAccessIterator& __first, _RandomAccessIterator& __lm1,
                                                            uint64_t& __left_bitset, uint64_t& __right_bitset) {
+  using _Ops = _IterOps<_AlgPolicy>;
   typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   if (__left_bitset) {
     // Swap within the left side.  Need to find set positions in the reverse
     // order.
     while (__left_bitset != 0) {
       difference_type __tz_left = __detail::__block_size - 1 - __libcpp_clz(__left_bitset);
       __left_bitset &= (static_cast<uint64_t>(1) << __tz_left) - 1;
       _RandomAccessIterator it = __first + __tz_left;
       if (it != __lm1) {
-        std::iter_swap(it, __lm1);
+        _Ops::iter_swap(it, __lm1);
       }
       --__lm1;
     }
     __first = __lm1 + difference_type(1);
   } else if (__right_bitset) {
     // Swap within the right side.  Need to find set positions in the reverse
     // order.
     while (__right_bitset != 0) {
       difference_type __tz_right = __detail::__block_size - 1 - __libcpp_clz(__right_bitset);
       __right_bitset &= (static_cast<uint64_t>(1) << __tz_right) - 1;
       _RandomAccessIterator it = __lm1 - __tz_right;
       if (it != __first) {
-        std::iter_swap(it, __first);
+        _Ops::iter_swap(it, __first);
       }
       ++__first;
     }
   }
 }
 
 // Partition [__first, __last) using the comparator __comp.  *__first has the
 // chosen pivot.  Elements that are equivalent are kept to the left of the
 // pivot.  Returns the iterator for the pivot and a bool value which is true if
 // the provided range is already sorted, false otherwise.  We assume that the
 // length of the range is at least three elements.
 //
 // __bitset_partition uses bitsets for storing outcomes of the comparisons
 // between the pivot and other elements.
-template <class _RandomAccessIterator, class _Compare>
+template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
 _LIBCPP_HIDE_FROM_ABI std::pair<_RandomAccessIterator, bool>
 __bitset_partition(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+  using _Ops = _IterOps<_AlgPolicy>;
   typedef typename std::iterator_traits<_RandomAccessIterator>::value_type value_type;
   typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   _LIBCPP_ASSERT(__last - __first >= difference_type(3), "");
 
   _RandomAccessIterator __begin = __first;
-  value_type __pivot(std::move(*__first));
+  value_type __pivot(_Ops::__iter_move(__first));
   // Find the first element greater than the pivot.
   if (__comp(__pivot, *(__last - difference_type(1)))) {
     // Not guarded since we know the last element is greater than the pivot.
     while (!__comp(__pivot, *++__first)) {
     }
   } else {
     while (++__first < __last && !__comp(__pivot, *__first)) {
     }
   }
   // Find the last element less than or equal to the pivot.
   if (__first < __last) {
     // It will be always guarded because __introsort will do the median-of-three
     // before calling this.
     while (__comp(__pivot, *--__last)) {
     }
   }
   // If the first element greater than the pivot is at or after the
   // last element less than or equal to the pivot, then we have covered the
   // entire range without swapping elements.  This implies the range is already
   // partitioned.
   bool __already_partitioned = __first >= __last;
   if (!__already_partitioned) {
-    std::iter_swap(__first, __last);
+    _Ops::iter_swap(__first, __last);
     ++__first;
   }
 
   // In [__first, __last) __last is not inclusive. From now on, it uses last
   // minus one to be inclusive on both sides.
   _RandomAccessIterator __lm1 = __last - difference_type(1);
   uint64_t __left_bitset = 0;
   uint64_t __right_bitset = 0;
 
   // Reminder: length = __lm1 - __first + 1.
   while (__lm1 - __first >= 2 * __detail::__block_size - 1) {
     // Record the comparison outcomes for the elements currently on the left
     // side.
     if (__left_bitset == 0)
       __populate_left_bitset<_Compare>(__first, __comp, __pivot, __left_bitset);
     // Record the comparison outcomes for the elements currently on the right
     // side.
     if (__right_bitset == 0)
       __populate_right_bitset<_Compare>(__lm1, __comp, __pivot, __right_bitset);
     // Swap the elements recorded to be the candidates for swapping in the
     // bitsets.
-    __swap_bitmap_pos(__first, __lm1, __left_bitset, __right_bitset);
+    __swap_bitmap_pos<_AlgPolicy, _RandomAccessIterator>(__first, __lm1, __left_bitset, __right_bitset);
     // Only advance the iterator if all the elements that need to be moved to
     // other side were moved.
     __first += (__left_bitset == 0) ? difference_type(__detail::__block_size) : difference_type(0);
     __lm1 -= (__right_bitset == 0) ? difference_type(__detail::__block_size) : difference_type(0);
   }
   // Now, we have a less-than a block worth of elements on at least one of the
   // sides.
-  __bitset_partition_partial_blocks<_Compare>(__first, __lm1, __comp, __pivot, __left_bitset, __right_bitset);
+  __bitset_partition_partial_blocks<_AlgPolicy, _Compare>(__first, __lm1, __comp, __pivot, __left_bitset, __right_bitset);
   // At least one the bitsets would be empty.  For the non-empty one, we need to
   // properly partition the elements that appear within that bitset.
-  __swap_bitmap_pos_within(__first, __lm1, __left_bitset, __right_bitset);
+  __swap_bitmap_pos_within<_AlgPolicy>(__first, __lm1, __left_bitset, __right_bitset);
 
   // Move the pivot to its correct position.
   _RandomAccessIterator __pivot_pos = __first - difference_type(1);
   if (__begin != __pivot_pos) {
-    *__begin = std::move(*__pivot_pos);
+    *__begin = _Ops::__iter_move(__pivot_pos);
   }
   *__pivot_pos = std::move(__pivot);
   return std::make_pair(__pivot_pos, __already_partitioned);
 }
 
 // Partition [__first, __last) using the comparator __comp.  *__first has the
 // chosen pivot.  Elements that are equivalent are kept to the right of the
 // pivot.  Returns the iterator for the pivot and a bool value which is true if
 // the provided range is already sorted, false otherwise.  We assume that the
 // length of the range is at least three elements.
-template <class _RandomAccessIterator, class _Compare>
+template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
 _LIBCPP_HIDE_FROM_ABI std::pair<_RandomAccessIterator, bool>
 __partition_with_equals_on_right(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+  using _Ops = _IterOps<_AlgPolicy>;
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   typedef typename std::iterator_traits<_RandomAccessIterator>::value_type value_type;
   _LIBCPP_ASSERT(__last - __first >= difference_type(3), "");
   _RandomAccessIterator __begin = __first;
-  value_type __pivot(std::move(*__first));
+  value_type __pivot(_Ops::__iter_move(__first));
   // Find the first element greater or equal to the pivot.  It will be always
   // guarded because __introsort will do the median-of-three before calling
   // this.
   while (__comp(*++__first, __pivot))
     ;
 
   // Find the last element less than the pivot.
   if (__begin == __first - difference_type(1)) {
     while (__first < __last && !__comp(*--__last, __pivot))
       ;
   } else {
     // Guarded.
     while (!__comp(*--__last, __pivot))
       ;
   }
 
   // If the first element greater than or equal to the pivot is at or after the
   // last element less than the pivot, then we have covered the entire range
   // without swapping elements.  This implies the range is already partitioned.
   bool __already_partitioned = __first >= __last;
   // Go through the remaining elements.  Swap pairs of elements (one to the
   // right of the pivot and the other to left of the pivot) that are not on the
   // correct side of the pivot.
   while (__first < __last) {
-    std::iter_swap(__first, __last);
+    _Ops::iter_swap(__first, __last);
     while (__comp(*++__first, __pivot))
       ;
     while (!__comp(*--__last, __pivot))
       ;
   }
   // Move the pivot to its correct position.
   _RandomAccessIterator __pivot_pos = __first - difference_type(1);
   if (__begin != __pivot_pos) {
-    *__begin = std::move(*__pivot_pos);
+    *__begin = _Ops::__iter_move(__pivot_pos);
   }
   *__pivot_pos = std::move(__pivot);
   return std::make_pair(__pivot_pos, __already_partitioned);
 }
 
 // Similar to the above function.  Elements equivalent to the pivot are put to
 // the left of the pivot.  Returns the iterator to the pivot element.
-template <class _RandomAccessIterator, class _Compare>
+template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
 _LIBCPP_HIDE_FROM_ABI _RandomAccessIterator __partition_with_equals_on_left(_RandomAccessIterator __first,
                                                                             _RandomAccessIterator __last,
                                                                             _Compare __comp) {
+  using _Ops = _IterOps<_AlgPolicy>;
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   typedef typename std::iterator_traits<_RandomAccessIterator>::value_type value_type;
   _RandomAccessIterator __begin = __first;
-  value_type __pivot(std::move(*__first));
+  value_type __pivot(_Ops::__iter_move(__first));
   if (__comp(__pivot, *(__last - difference_type(1)))) {
     // Guarded.
     while (!__comp(__pivot, *++__first)) {
     }
   } else {
     while (++__first < __last && !__comp(__pivot, *__first)) {
     }
   }
 
   if (__first < __last) {
     // It will be always guarded because __introsort will do the
     // median-of-three before calling this.
     while (__comp(__pivot, *--__last)) {
     }
   }
   while (__first < __last) {
-    std::iter_swap(__first, __last);
+    _Ops::iter_swap(__first, __last);
     while (!__comp(__pivot, *++__first))
       ;
     while (__comp(__pivot, *--__last))
       ;
   }
   _RandomAccessIterator __pivot_pos = __first - difference_type(1);
   if (__begin != __pivot_pos) {
-    *__begin = std::move(*__pivot_pos);
+    *__begin = _Ops::__iter_move(__pivot_pos);
   }
   *__pivot_pos = std::move(__pivot);
   return __first;
 }
 
 // The main sorting function.  Implements introsort combined with other ideas:
 //  - option of using block quick sort for partitioning,
 //  - guarded and unguarded insertion sort for small lengths,
void __introsort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
   while (true) {
     difference_type __len = __last - __first;
     switch (__len) {
     case 0:
     case 1:
       return;
     case 2:
       if (__comp(*--__last, *__first))
-        _IterOps<_AlgPolicy>::iter_swap(__first, __last);
+        _Ops::iter_swap(__first, __last);
       return;
     case 3:
       std::__sort3_maybe_branchless<_AlgPolicy, _Compare>(__first, __first + difference_type(1), --__last, __comp);
       return;
     case 4:
       std::__sort4_maybe_branchless<_AlgPolicy, _Compare>(
           __first, __first + difference_type(1), __first + difference_type(2), --__last, __comp);
       return;
--__depth;
       // depending on the length of the range being sorted.
       if (__len > __ninther_threshold) {
         std::__sort3<_AlgPolicy, _Compare>(__first, __first + __half_len, __last - difference_type(1), __comp);
         std::__sort3<_AlgPolicy, _Compare>(__first + difference_type(1), __first + (__half_len - 1), __last - difference_type(2),
                                __comp);
         std::__sort3<_AlgPolicy, _Compare>(__first + difference_type(2), __first + (__half_len + 1), __last - difference_type(3),
                                __comp);
         std::__sort3<_AlgPolicy, _Compare>(__first + (__half_len - 1), __first + __half_len, __first + (__half_len + 1), __comp);
-        std::iter_swap(__first, __first + __half_len);
+        _Ops::iter_swap(__first, __first + __half_len);
       } else {
         std::__sort3<_AlgPolicy, _Compare>(__first + __half_len, __first, __last - difference_type(1), __comp);
       }
     }
     // The elements to the left of the current iterator range are already
     // sorted.  If the current iterator range to be sorted is not the
     // leftmost part of the entire iterator range and the pivot is same as
     // the highest element in the range to the left, then we know that all
     // the elements in the range [first, pivot] would be equal to the pivot,
     // assuming the equal elements are put on the left side when
     // partitioned.  This also means that we do not need to sort the left
     // side of the partition.
     if (!__leftmost && !__comp(*(__first - difference_type(1)), *__first)) {
-      __first = __partition_with_equals_on_left<_RandomAccessIterator, _Comp_ref>(__first, __last, _Comp_ref(__comp));
+      __first = __partition_with_equals_on_left<_AlgPolicy, _RandomAccessIterator, _Comp_ref>(__first, __last, _Comp_ref(__comp));
       continue;
     }
     // Use bitset partition only if asked for.
     auto __ret = _UseBitSetPartition
-                     ? __bitset_partition<_RandomAccessIterator, _Compare>(__first, __last, __comp)
-                     : __partition_with_equals_on_right<_RandomAccessIterator, _Compare>(__first, __last, __comp);
+                     ? __bitset_partition<_AlgPolicy, _RandomAccessIterator, _Compare>(__first, __last, __comp)
+                     : __partition_with_equals_on_right<_AlgPolicy, _RandomAccessIterator, _Compare>(__first, __last, __comp);
     _RandomAccessIterator __i = __ret.first;
     // [__first, __i) < *__i and *__i <= [__i+1, __last)
     // If we were given a perfect partition, see if insertion sort is quick...
     if (__ret.second) {
       using _WrappedComp = typename _WrapAlgPolicy<_AlgPolicy, _Compare>::type;
       _WrappedComp __wrapped_comp(__comp);
       bool __fs = std::__insertion_sort_incomplete<_WrappedComp>(__first, __i, __wrapped_comp);
       if (std::__insertion_sort_incomplete<_WrappedComp>(__i + difference_type(1), __last, __wrapped_comp)) {