[RFC][libc++] Allow non-copyable OutputIterators.

[Mordante]

Summary

Starting with C++20 (input and) output iterators. This patch is a
proof-of-concept only modifying one algorithm.

When we're happy with this patch I want look at similar fixes for the
other iterators. (As seen in the build errors there are quite some
places that need fixes.)

Noticed this while working on LWG3539
format_to must not copy models of output_iterator<const charT&>

Depends on D117395

[• Quuxplusone]

libcxx/include/__config

1084–1094

You don't need this; you should _VSTD::move(__it) unconditionally. Even in C++11, if a type It supports

it = jt;  // OK
it = It(jt);  // compiler error

then it is not an iterator type. Iterators have to be copyable, and that includes movable as a subcondition.
Also, moving is never slower than copying. If C++20 forces us to update some copies to moves, we should do the upgrade unconditionally. (Even in C++03, where _VSTD::move is supported as an extension.)

libcxx/test/support/test_iterators.h

35–42

This is inconsistent with the tactic we picked for input_iterator: We now have a cpp17_input_iterator<T*> and a cpp20_input_iterator<T*> as two differently named types, and we test them both in C++20 mode.
Should we just use this (much simpler) tactic for both output_iterator and input_iterator?
If there's a good reason not to use this tactic for input_iterator, then, does that same good reason apply to output_iterator?

[Mordante]

Thanks for the input, I think using std::move is the way forward.

libcxx/include/__config

1084–1094

I forgot we allow _VSTD::move in C++03 mode. That makes this change unneeded and makes the changes a lot simpler. Thanks for the reminder!

libcxx/test/support/test_iterators.h

35–42

It depends on whether Cpp17OutputIterator is used in C++20? If it is we need a second version. This is a quick test to see what fails.

[Mordante]

libcxx/test/support/test_iterators.h

35–42

Actually it seems Cpp17OutputIterator is used. The comment for cpp17_input_iterator is misleading. The algorithms still use the same requirements as C++17. D117950 renames the current requirements, making the way free to add new C++20 iterator.

[Mordante]

With ranges completed there's no need to use pre-C++20 algorithms. Since it will be quite a bit of effort to adjust all algorithms and it has a very low priority I abandon this instead.

libcxx/include/__algorithm/fill_n.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_FILL_N_H
 #define _LIBCPP___ALGORITHM_FILL_N_H
 
+#include <__algorithm/move.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
     return __first;
 }
 
 template <class _OutputIterator, class _Size, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
 {
-   return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value_);
+   return _VSTD::__fill_n(_LIBCPP_MOVE_AFTER_CXX17(__first), _VSTD::__convert_to_integral(__n), __value_);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_FILL_N_H

libcxx/include/__config

 #endif
 
 #if _LIBCPP_STD_VER > 17
 #  define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr
 #else
 #  define _LIBCPP_CONSTEXPR_AFTER_CXX17
 #endif
 
+// In C++17 (and earlier) an iterator is required to be CopyConstructible and
+// CopyAssignable, but not MoveConstructibe nor MoveAssignable.
+// In C++20 the concepts input_iterator and output_iterator require movable but
+// not copyable. (forward_iterator requires copyable.)
+// Depending on the standard used some algorithms need to be adapted, for
+// example fill_n calls __fill_n with an OutputIterator argument.
+#if _LIBCPP_STD_VER > 17
+#  define _LIBCPP_MOVE_AFTER_CXX17(__obj) _VSTD::move(__obj)
+#else
+#  define _LIBCPP_MOVE_AFTER_CXX17(__obj) __obj
+#endif
+
 #if __has_cpp_attribute(nodiscard) || defined(_LIBCPP_COMPILER_MSVC)
 #  define _LIBCPP_NODISCARD [[nodiscard]]
 #elif defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(_LIBCPP_CXX03_LANG)
 #  define _LIBCPP_NODISCARD [[clang::warn_unused_result]]
 #else
 // We can't use GCC's [[gnu::warn_unused_result]] and
 // __attribute__((warn_unused_result)), because GCC does not silence them via
 // (void) cast.

libcxx/test/support/test_iterators.h

public:
     typedef void                                               value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 output_iterator() {}
+#if TEST_STD_VER > 17
+    // Starting with C++20 an output_iterator must be movable and doesn't
+    // require copyable.
+    output_iterator(const output_iterator&) = delete;
+    output_iterator(output_iterator&&) = default;
+    output_iterator& operator=(const output_iterator&) = delete;
+    output_iterator& operator=(output_iterator&&) = default;
+#endif
     explicit TEST_CONSTEXPR_CXX14 output_iterator(It it) : it_(it) {}
     template <class U>
         TEST_CONSTEXPR_CXX14 output_iterator(const output_iterator<U>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
 
     TEST_CONSTEXPR_CXX14 output_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 output_iterator operator++(int)