[libc++] Comma-operator-proof a lot of algorithm/container code.

[• Quuxplusone]

Summary

Detected by evil-izing the widely used MoveOnly testing type.
I had to patch some tests that were themselves using its comma operator, but I think that's a worthwhile cost in order to catch more places in our headers that needed comma-proofing.

The trick here is that even ++ptr, ++ptr can find a comma operator by ADL, if ptr is of type Evil*.

libcxx/include/__algorithm/stable_sort.h

 {
     typedef typename iterator_traits<_InputIterator1>::value_type value_type;
     __destruct_n __d(0);
     unique_ptr<value_type, __destruct_n&> __h(__result, __d);
     for (; true; ++__result)
     {
         if (__first1 == __last1)
         {
-            for (; __first2 != __last2; ++__first2, ++__result, (void)__d.template __incr<value_type>())
+            for (; __first2 != __last2; ++__first2, (void) ++__result, __d.template __incr<value_type>())
                 ::new ((void*)__result) value_type(_VSTD::move(*__first2));
             __h.release();
             return;
         }
         if (__first2 == __last2)
         {
-            for (; __first1 != __last1; ++__first1, ++__result, (void)__d.template __incr<value_type>())
+            for (; __first1 != __last1; ++__first1, (void) ++__result, __d.template __incr<value_type>())
                 ::new ((void*)__result) value_type(_VSTD::move(*__first1));
             __h.release();
             return;
         }
         if (__comp(*__first2, *__first1))
         {
             ::new ((void*)__result) value_type(_VSTD::move(*__first2));
             __d.template __incr<value_type>();

libcxx/include/__hash_table

if (__nbc > 0)
             __bucket_list_[__i] = nullptr;
         __next_pointer __pp = __p1_.first().__ptr();
         __next_pointer __cp = __pp->__next_;
         if (__cp != nullptr)
         {
             size_type __chash = __constrain_hash(__cp->__hash(), __nbc);
             __bucket_list_[__chash] = __pp;
             size_type __phash = __chash;
-            for (__pp = __cp, __cp = __cp->__next_; __cp != nullptr;
+            for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr;
                                                            __cp = __pp->__next_)
             {
                 __chash = __constrain_hash(__cp->__hash(), __nbc);
                 if (__chash == __phash)
                     __pp = __cp;
                 else
                 {
                     if (__bucket_list_[__chash] == nullptr)
_LIBCPP_ASSERT(__n < bucket_count(),
         "unordered container::bucket_size(n) called with n >= bucket_count()");
     __next_pointer __np = __bucket_list_[__n];
     size_type __bc = bucket_count();
     size_type __r = 0;
     if (__np != nullptr)
     {
         for (__np = __np->__next_; __np != nullptr &&
                                    __constrain_hash(__np->__hash(), __bc) == __n;
-                                                    __np = __np->__next_, ++__r)
+                                                    __np = __np->__next_, (void) ++__r)
             ;
     }
     return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void

libcxx/include/__memory/uninitialized_algorithms.h

 template <class _ForwardIterator, class _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
     using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
-    for (; __n > 0; (void)++__idx, --__n)
+    for (; __n > 0; ++__idx, (void) --__n)
         ::new ((void*)_VSTD::addressof(*__idx)) _Vt;
     return __idx;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first, __idx);
         throw;
     }
 #endif

 template <class _ForwardIterator, class _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
     using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
-    for (; __n > 0; (void)++__idx, --__n)
+    for (; __n > 0; ++__idx, (void) --__n)
         ::new ((void*)_VSTD::addressof(*__idx)) _Vt();
     return __idx;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first, __idx);
         throw;
     }
 #endif
 }
 
 
 template <class _InputIt, class _ForwardIt>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) {
     using _Vt = typename iterator_traits<_ForwardIt>::value_type;
     auto __idx = __first_res;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
-    for (; __first != __last; (void)++__idx, ++__first)
+    for (; __first != __last; ++__idx, (void) ++__first)
         ::new ((void*)_VSTD::addressof(*__idx)) _Vt(_VSTD::move(*__first));
     return __idx;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first_res, __idx);
         throw;
     }
 #endif
 }
 
 template <class _InputIt, class _Size, class _ForwardIt>
 inline _LIBCPP_INLINE_VISIBILITY
 pair<_InputIt, _ForwardIt>
 uninitialized_move_n(_InputIt __first, _Size __n, _ForwardIt __first_res) {
     using _Vt = typename iterator_traits<_ForwardIt>::value_type;
     auto __idx = __first_res;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
-    for (; __n > 0; ++__idx, (void)++__first, --__n)
+    for (; __n > 0; ++__idx, (void) ++__first, --__n)
         ::new ((void*)_VSTD::addressof(*__idx)) _Vt(_VSTD::move(*__first));
     return {__first, __idx};
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first_res, __idx);
         throw;
     }
 #endif
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H

libcxx/include/__split_buffer

__split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last)
     __alloc_rr& __a = this->__alloc();
     for (; __first != __last; ++__first)
     {
         if (__end_ == __end_cap())
         {
             size_type __old_cap = __end_cap() - __first_;
             size_type __new_cap = _VSTD::max<size_type>(2 * __old_cap, 8);
             __split_buffer __buf(__new_cap, 0, __a);
-            for (pointer __p = __begin_; __p != __end_; ++__p, ++__buf.__end_)
+            for (pointer __p = __begin_; __p != __end_; ++__p, (void) ++__buf.__end_)
                 __alloc_traits::construct(__buf.__alloc(),
                         _VSTD::__to_address(__buf.__end_), _VSTD::move(*__p));
             swap(__buf);
         }
         __alloc_traits::construct(__a, _VSTD::__to_address(this->__end_), *__first);
         ++this->__end_;
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <
     __is_cpp17_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
 {
     _ConstructTransaction __tx(&this->__end_, _VSTD::distance(__first, __last));
-    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, ++__first) {
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void) ++__first) {
         __alloc_traits::construct(this->__alloc(),
             _VSTD::__to_address(__tx.__pos_), *__first);
     }
 }
 
 template <class _Tp, class _Allocator>
 inline
 void

libcxx/include/deque

else
         if (__n > __back_capacity)
             __add_back_capacity(__n - __back_capacity);
         // __n <= __back_capacity
         iterator __old_end = __base::end();
         iterator __i = __old_end;
         size_type __de = __base::size() - __pos;
         if (__n > __de)
         {
-            for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size())
+            for (size_type __m = __n - __de; __m; --__m, (void) ++__i, ++__base::size())
                 __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
             __n = __de;
         }
         if (__n > 0)
         {
             const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
             iterator __oen = __old_end - __n;
             __move_construct_and_check(__oen, __old_end, __i, __vt);
else
             __m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de);
             for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__base::size())
                 __alloc_traits::construct(__a, _VSTD::addressof(*__i), *__j);
             __n = __de;
         }
         if (__n > 0)
         {
             iterator __oen = __old_end - __n;
-            for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size())
+            for (iterator __j = __oen; __j != __old_end; ++__i, (void) ++__j, ++__base::size())
                 __alloc_traits::construct(__a, _VSTD::addressof(*__i), _VSTD::move(*__j));
             if (__n < __de)
                 __old_end = _VSTD::move_backward(__old_end - __de, __oen, __old_end);
             _VSTD::copy_backward(__f, __m, __old_end);
         }
     }
     return __base::begin() + __pos;
 }

libcxx/include/list

 template <class _Tp, class _Alloc>
 template <class _InpIter>
 void
 list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l,
                           typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*)
 {
     iterator __i = begin();
     iterator __e = end();
-    for (; __f != __l && __i != __e; ++__f, ++__i)
+    for (; __f != __l && __i != __e; ++__f, (void) ++__i)
         *__i = *__f;
     if (__i == __e)
         insert(__e, __f, __l);
     else
         erase(__i, __e);
 #if _LIBCPP_DEBUG_LEVEL == 2
       __get_db()->__invalidate_all(this);
 #endif
 }
 
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x)
 {
     iterator __i = begin();
     iterator __e = end();
-    for (; __n > 0 && __i != __e; --__n, ++__i)
+    for (; __n > 0 && __i != __e; --__n, (void) ++__i)
         *__i = __x;
     if (__i == __e)
         insert(__e, __n, __x);
     else
         erase(__i, __e);
 #if _LIBCPP_DEBUG_LEVEL == 2
       __get_db()->__invalidate_all(this);
 #endif
#else
         __r = iterator(__hold->__as_link());
 #endif
         __hold.release();
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
-            for (--__n; __n != 0; --__n, ++__e, ++__ds)
+            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
                 __e.__ptr_->__next_ = __hold->__as_link();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
#else
         __r = iterator(__hold.get()->__as_link());
 #endif
         __hold.release();
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
-            for (++__f; __f != __l; ++__f, (void) ++__e, (void) ++__ds)
+            for (++__f; __f != __l; ++__f, (void) ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS

 #else
         iterator __r = iterator(__hold.release()->__as_link());
 #endif
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
-            for (--__n; __n != 0; --__n, ++__e, ++__ds)
+            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS

 #else
         iterator __r = iterator(__nl);
 #endif
         iterator __e = __r;
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
-            for (--__n; __n != 0; --__n, ++__e, ++__ds)
+            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
                 __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
                 __e.__ptr_->__next_ = __hold.get()->__as_link();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
if (this != _VSTD::addressof(__c))
         iterator __f2 = __c.begin();
         iterator __e2 = __c.end();
         while (__f1 != __e1 && __f2 != __e2)
         {
             if (__comp(*__f2, *__f1))
             {
                 size_type __ds = 1;
                 iterator __m2 = _VSTD::next(__f2);
-                for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds)
+                for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, (void) ++__ds)
                     ;
                 base::__sz() += __ds;
                 __c.__sz() -= __ds;
                 __link_pointer __f = __f2.__ptr_;
                 __link_pointer __l = __m2.__ptr_->__prev_;
                 __f2 = __m2;
                 base::__unlink_nodes(__f, __l);
                 __m2 = _VSTD::next(__f1);

libcxx/include/string

if (__string_is_trivial_iterator<_ForwardIterator>::value &&
         (__cap >= __n || !__addr_in_range(*__first)))
     {
         if (__cap < __n)
         {
             size_type __sz = size();
             __grow_by(__cap, __n - __cap, __sz, 0, __sz);
         }
         pointer __p = __get_pointer();
-        for (; __first != __last; ++__first, ++__p)
+        for (; __first != __last; ++__p, (void) ++__first)
             traits_type::assign(*__p, *__first);
         traits_type::assign(*__p, value_type());
         __set_size(__n);
         __invalidate_iterators_past(__n);
     }
     else
     {
         const basic_string __temp(__first, __last, __alloc());
basic_string<_CharT, _Traits, _Allocator>::append(
     if (__n)
     {
         if (__string_is_trivial_iterator<_ForwardIterator>::value &&
             !__addr_in_range(*__first))
         {
             if (__cap - __sz < __n)
                 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
             pointer __p = __get_pointer() + __sz;
-            for (; __first != __last; ++__p, ++__first)
+            for (; __first != __last; ++__p, (void) ++__first)
                 traits_type::assign(*__p, *__first);
             traits_type::assign(*__p, value_type());
             __set_size(__sz + __n);
         }
         else
         {
             const basic_string __temp(__first, __last, __alloc());
             append(__temp.data(), __temp.size());
if (__n)
             else
             {
                 __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
                 __p = _VSTD::__to_address(__get_long_pointer());
             }
             __sz += __n;
             __set_size(__sz);
             traits_type::assign(__p[__sz], value_type());
-            for (__p += __ip; __first != __last; ++__p, ++__first)
+            for (__p += __ip; __first != __last; ++__p, (void) ++__first)
                 traits_type::assign(*__p, *__first);
         }
         else
         {
             const basic_string __temp(__first, __last, __alloc());
             return insert(__pos, __temp.data(), __temp.data() + __temp.size());
         }
     }

libcxx/include/vector

 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
 {
     _ConstructTransaction __tx(*this, __n);
     const_pointer __new_end = __tx.__new_end_;
-    for (pointer __pos = __tx.__pos_; __pos != __new_end; ++__pos, __tx.__pos_ = __pos) {
+    for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
         __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos));
     }
 }
 
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
 inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
     _ConstructTransaction __tx(*this, __n);
     const_pointer __new_end = __tx.__new_end_;
-    for (pointer __pos = __tx.__pos_; __pos != __new_end; ++__pos, __tx.__pos_ = __pos) {
+    for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
         __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__pos), __x);
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
 <

 vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to)
 {
     pointer __old_last = this->__end_;
     difference_type __n = __old_last - __to;
     {
       pointer __i = __from_s + __n;
       _ConstructTransaction __tx(*this, __from_e - __i);
       for (pointer __pos = __tx.__pos_; __i < __from_e;
-           ++__i, ++__pos, __tx.__pos_ = __pos) {
+           ++__i, (void) ++__pos, __tx.__pos_ = __pos) {
           __alloc_traits::construct(this->__alloc(),
                                     _VSTD::__to_address(__pos),
                                     _VSTD::move(*__i));
       }
     }
     _VSTD::move_backward(__from_s, __from_s + __n, __old_last);
 }
 

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

#if TEST_STD_VER >= 11
     C c;
     typedef typename C::const_iterator CI;
     {
         MoveOnly mo(0);
         typedef MoveOnly* I;
         c.insert(c.end(), std::move_iterator<I>(&mo), std::move_iterator<I>(&mo+1));
     }
     int j = 0;
-    for (CI i = c.begin(); i != c.end(); ++i, ++j)
+    for (CI i = c.begin(); i != c.end(); ++i, (void) ++j)
         assert(*i == MoveOnly(j));
     {
         MoveOnly mo(1);
         typedef cpp17_input_iterator<MoveOnly*> I;
         c.insert(c.end(), std::move_iterator<I>(I(&mo)), std::move_iterator<I>(I(&mo+1)));
     }
     j = 0;
-    for (CI i = c.begin(); i != c.end(); ++i, ++j)
+    for (CI i = c.begin(); i != c.end(); ++i, (void) ++j)
         assert(*i == MoveOnly(j));
 #endif
 }
 
 int main(int, char**)
 {
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp

 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, MoveOnly(x));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
     assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
-    for (int j = 0; j < P; ++j, ++i)
+    for (int j = 0; j < P; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
     assert(*i == MoveOnly(x));
     ++i;
-    for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
+    for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     for (int i = 0; i <= 3; ++i)

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_back_rvalue.pass.cpp

 void test(int size)
 {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int j = 0; j < N; ++j)
     {
         C c = make<C>(size, rng[j]);
         typename C::const_iterator it = c.begin();
-        for (int i = 0; i < size; ++i, ++it)
+        for (int i = 0; i < size; ++i, (void) ++it)
             assert(*it == MoveOnly(i));
     }
 }
 
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp

test(C& c1, int x)
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.push_front(MoveOnly(x));
     assert(c1.size() == c1_osize + 1);
     assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     assert(*i == MoveOnly(x));
     ++i;
-    for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
+    for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     C c1 = make<C>(N, start);

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_move.pass.cpp

int main(int, char**)
         typedef std::forward_list<T, A> C;
         T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         T t1[] = {10, 11, 12, 13};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(10));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == n);
         assert(n == 10);
         assert(c1.get_allocator() == A(10));
         assert(c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         T t1[] = {10, 11, 12, 13};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(11));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == n);
         assert(n == 10);
         assert(c1.get_allocator() == A(11));
         assert(!c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {10, 11, 12, 13};
         T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(10));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == 10+n);
         assert(n == 4);
         assert(c1.get_allocator() == A(10));
         assert(c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {10, 11, 12, 13};
         T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(11));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == 10+n);
         assert(n == 4);
         assert(c1.get_allocator() == A(11));
         assert(!c0.empty());
     }
 
     {
         typedef MoveOnly T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         T t1[] = {10, 11, 12, 13};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(10));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == n);
         assert(n == 10);
         assert(c1.get_allocator() == A(10));
         assert(c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         T t1[] = {10, 11, 12, 13};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(11));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == n);
         assert(n == 10);
         assert(c1.get_allocator() == A(10));
         assert(c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {10, 11, 12, 13};
         T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(10));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == 10+n);
         assert(n == 4);
         assert(c1.get_allocator() == A(10));
         assert(c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {10, 11, 12, 13};
         T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A(10));
         C c1(I(std::begin(t1)), I(std::end(t1)), A(11));
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == 10+n);
         assert(n == 4);
         assert(c1.get_allocator() == A(10));
         assert(c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         T t1[] = {10, 11, 12, 13};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A());
         C c1(I(std::begin(t1)), I(std::end(t1)), A());
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == n);
         assert(n == 10);
         assert(c1.get_allocator() == A());
         assert(c0.empty());
     }
     {
         typedef MoveOnly T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t0[] = {10, 11, 12, 13};
         T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t0)), I(std::end(t0)), A());
         C c1(I(std::begin(t1)), I(std::end(t1)), A());
         c1 = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, ++n)
+        for (C::const_iterator i = c1.cbegin(); i != c1.cend(); ++i, (void) ++n)
             assert(*i == 10+n);
         assert(n == 4);
         assert(c1.get_allocator() == A());
         assert(c0.empty());
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/move.pass.cpp

int main(int, char**)
         typedef MoveOnly T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t)), I(std::end(t)), A(10));
         C c = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
+        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, (void) ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c0.empty());
         assert(c.get_allocator() == A(10));
     }
     {
         typedef MoveOnly T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t)), I(std::end(t)), A(10));
         C c = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
+        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, (void) ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c0.empty());
         assert(c.get_allocator() == A(10));
     }
     {
         typedef MoveOnly T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t)), I(std::end(t)), A());
         C c = std::move(c0);
         int n = 0;
-        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
+        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, (void) ++n)
             assert(*i == n);
         assert(n == std::end(t) - std::begin(t));
         assert(c0.empty());
         assert(c.get_allocator() == A());
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/move_alloc.pass.cpp

int main(int, char**)
         typedef MoveOnly T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t)), I(std::end(t)), A(10));
         C c(std::move(c0), A(10));
         unsigned n = 0;
-        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
+        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, (void) ++n)
             assert(*i == n);
         assert(n == static_cast<unsigned>(std::end(t) - std::begin(t)));
         assert(c0.empty());
         assert(c.get_allocator() == A(10));
     }
     {
         typedef MoveOnly T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t)), I(std::end(t)), A(10));
         C c(std::move(c0), A(9));
         unsigned n = 0;
-        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
+        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, (void) ++n)
             assert(*i == n);
         assert(n == static_cast<unsigned>(std::end(t) - std::begin(t)));
         assert(!c0.empty());
         assert(c.get_allocator() == A(9));
     }
     {
         typedef MoveOnly T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         typedef std::move_iterator<T*> I;
         C c0(I(std::begin(t)), I(std::end(t)), A());
         C c(std::move(c0), A());
         unsigned n = 0;
-        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, ++n)
+        for (C::const_iterator i = c.begin(), e = c.end(); i != e; ++i, (void) ++n)
             assert(*i == n);
         assert(n == static_cast<unsigned>(std::end(t) - std::begin(t)));
         assert(c0.empty());
         assert(c.get_allocator() == A());
     }
 
   return 0;
 }

libcxx/test/support/MoveOnly.h

friend constexpr bool operator> (const MoveOnly& x, const MoveOnly& y)
         { return x.data_ >  y.data_; }
     friend constexpr bool operator>=(const MoveOnly& x, const MoveOnly& y)
         { return x.data_ >= y.data_; }
 
     TEST_CONSTEXPR_CXX14 MoveOnly operator+(const MoveOnly& x) const
         { return MoveOnly{data_ + x.data_}; }
     TEST_CONSTEXPR_CXX14 MoveOnly operator*(const MoveOnly& x) const
         { return MoveOnly{data_ * x.data_}; }
+
+    template<class T, class U>
+    friend void operator,(T t, U u) = delete;
 };
 
 namespace std {
 
 template <>
 struct hash<MoveOnly>
 {
     typedef MoveOnly argument_type;