[libc++][test] Adds an cpp20_output_iterator.

[Mordante]

Summary

This iterator is used to test code that only needs to satisfy the
output_iterator concept. Follow-up changes will use this iterator in
older language Standards.

[Mordante]

@philnik if you start to work on the modifying ranges patches this new iterator will be useful for your tests.

libcxx/test/support/test_iterators.h

531

If D122074 is abandoned, there's no need for the pre C++20 support in this class.

[Mordante]

Since D122074 is on hold (and might be abandoned) I want to remove all pre-c++20 features from this patch.
The patch is still useful for testing in the range based algorithms.

[CaseyCarter]

libcxx/test/support/test_iterators.h

541

This won't compile - *this is move-only,

[philnik]

It would be great if you remove the pre C++20 stuff. This would be nice to have for the ranges algorithm tests.

libcxx/test/support/test_iterators.h

540–544

The post-increment operator++ return void with the ranges stuff.

[Mordante]

libcxx/test/support/test_iterators.h

540–544

Unfortunately that won't work since the concept requires *__it++ = _VSTD::forward<_Tp>(__t);, deferring a void won't work.

541

Good point, thanks!

[Mordante]

Rebase.
Address review comments.
Change to C++20 iterator only.

[philnik]

LGTM

libcxx/test/support/test_iterators.h

540–544

That's not very intuitive, but OK.

[philnik]

Gentle ping; I need this for ranges::fill.

[var-const]

Thanks for working on this!

[ldionne]

LGTM, but what's the difference between C++17's output iterator and C++20's?

[Mordante]

In D122072#3427771, @ldionne wrote:

LGTM, but what's the difference between C++17's output iterator and C++20's?

That an output iterator in C++20 doesn't need to be copyable.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.output/output_iterator.compile.pass.cpp

 static_assert( std::output_iterator<cpp17_output_iterator<int*>, short>);
 static_assert( std::output_iterator<cpp17_output_iterator<int*>, long>);
 static_assert( std::output_iterator<cpp17_output_iterator<T*>, T>);
 static_assert(!std::output_iterator<cpp17_output_iterator<T const*>, T>);
 static_assert( std::output_iterator<cpp17_output_iterator<T*>, T const>);
 static_assert( std::output_iterator<cpp17_output_iterator<T*>, DerivedFromT>);
 static_assert(!std::output_iterator<cpp17_output_iterator<DerivedFromT*>, T>);
 
+static_assert( std::output_iterator<cpp20_output_iterator<int*>, int>);
+static_assert( std::output_iterator<cpp20_output_iterator<int*>, short>);
+static_assert( std::output_iterator<cpp20_output_iterator<int*>, long>);
+static_assert( std::output_iterator<cpp20_output_iterator<T*>, T>);
+static_assert(!std::output_iterator<cpp20_output_iterator<T const*>, T>);
+static_assert( std::output_iterator<cpp20_output_iterator<T*>, T const>);
+static_assert( std::output_iterator<cpp20_output_iterator<T*>, DerivedFromT>);
+static_assert(!std::output_iterator<cpp20_output_iterator<DerivedFromT*>, T>);
+
 // Not satisfied when the iterator is not an input_or_output_iterator
 static_assert(!std::output_iterator<void, int>);
 static_assert(!std::output_iterator<void (*)(), int>);
 static_assert(!std::output_iterator<int&, int>);
 static_assert(!std::output_iterator<T, int>);
 
 // Not satisfied when we can't assign a T to the result of *it++
 struct WrongPostIncrement {

libcxx/test/support/test_iterators.h

 template<std::input_or_output_iterator>
 struct iter_value_or_void { using type = void; };
 
 template<std::input_iterator I>
 struct iter_value_or_void<I> {
     using type = std::iter_value_t<I>;
 };
 
+template <class It>
+class cpp20_output_iterator {
+  It it_;
+
+public:
+  using difference_type = std::iter_difference_t<It>;
+
+  constexpr explicit cpp20_output_iterator(It it) : it_(it) {}
+  cpp20_output_iterator(cpp20_output_iterator&&) = default;
+  cpp20_output_iterator& operator=(cpp20_output_iterator&&) = default;
+
+  constexpr decltype(auto) operator*() const { return *it_; }
+  constexpr cpp20_output_iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr cpp20_output_iterator operator++(int) { return cpp20_output_iterator(it_++); }
+
+  friend constexpr It base(const cpp20_output_iterator& i) { return i.it_; }
+
+  template <class T>
+  void operator,(T const&) = delete;
+};
+
+static_assert(std::output_iterator<cpp20_output_iterator<int*>, int>);
+
 // Iterator adaptor that counts the number of times the iterator has had a successor/predecessor
 // operation called. Has two recorders:
 // * `stride_count`, which records the total number of calls to an op++, op--, op+=, or op-=.
 // * `stride_displacement`, which records the displacement of the calls. This means that both
 //   op++/op+= will increase the displacement counter by 1, and op--/op-= will decrease the
 //   displacement counter by 1.
 template <class It>
 class stride_counting_iterator {
 public: