[libc++] [ranges] Implement move_sentinel and C++20 move_iterator

[• Quuxplusone]

Added tests for move_sentinel. Still missing: tests for the iterator_traits of move_iterator; tests for three-way comparison; tests for iter_move and iter_swap.

[• Quuxplusone]

libcxx/include/__iterator/move_iterator.h

191

I found that writing the naïve requires requires { __x.base() == __y.base(); } here did not work; Clang complains something about accessing into incomplete type move_iterator<X> when you go to instantiate it. Pulling the constraint out into a concept outside the body of the class seems to fix the issue.

[• Quuxplusone]

Rebase, add more tests for comparison operators.
Could still use more tests for

• iterator_traits
• iter_move
• iter_swap

But I think this is pretty much ready to have people start hammering on it.

[jloser]

libcxx/include/__iterator/move_iterator.h

105

s/_LIBCPP_CONSTEXPR_AFTER_CXX14/constexpr here and below since we're already guarded with #if _LIBCPP_STD_VER > 17.

191

I'll buy that. I've also run into this several times in other codebases with requires requires expressions in member functions of a class template. It's not great, but the usual "pull it out to a named concept" works.

[• Quuxplusone]

Rebase, coalesce some repeated ifdefs, use unadorned constexpr in C++20-only codepaths

[ldionne]

This LGTM -- I think we can add a few more tests post-commit, but this looks reasonable as-is too. I'll rebase and ship this.

libcxx/docs/Status/Cxx20Issues.csv

 "`3381 <https://wg21.link/LWG3381>`__","``begin``\  and ``data``\  must agree for ``contiguous_range``\ ","Prague","","","|ranges|"
 "`3382 <https://wg21.link/LWG3382>`__","NTTP for ``pair``\  and ``array``\ ","Prague","",""
 "`3383 <https://wg21.link/LWG3383>`__","|sect|\ [time.zone.leap.nonmembers] ``sys_seconds``\  should be replaced with ``seconds``\ ","Prague","","","|chrono|"
 "`3384 <https://wg21.link/LWG3384>`__","``transform_view::*sentinel*``\  has an incorrect ``operator-``\ ","Prague","","","|ranges|"
 "`3385 <https://wg21.link/LWG3385>`__","``common_iterator``\  is not sufficiently constrained for non-copyable iterators","Prague","","","|ranges|"
 "`3387 <https://wg21.link/LWG3387>`__","|sect|\ [range.reverse.view] ``reverse_view<V>``\  unintentionally requires ``range<const V>``\ ","Prague","","","|ranges|"
 "`3388 <https://wg21.link/LWG3388>`__","``view``\  iterator types have ill-formed ``<=>``\  operators","Prague","","","|ranges|"
 "`3389 <https://wg21.link/LWG3389>`__","A move-only iterator still does not have a ``counted_iterator``\ ","Prague","","","|ranges|"
-"`3390 <https://wg21.link/LWG3390>`__","``make_move_iterator()``\  cannot be used to construct a ``move_iterator``\  for a move-only iterator","Prague","","","|ranges|"
+"`3390 <https://wg21.link/LWG3390>`__","``make_move_iterator()``\  cannot be used to construct a ``move_iterator``\  for a move-only iterator","Prague","|Complete|","14.0","|ranges|"
 "`3393 <https://wg21.link/LWG3393>`__","Missing/incorrect feature test macro for coroutines","Prague","|Complete|","14.0"
 "`3395 <https://wg21.link/LWG3395>`__","Definition for three-way comparison needs to be updated (US 152)","Prague","","","|spaceship|"
 "`3396 <https://wg21.link/LWG3396>`__","Clarify point of reference for ``source_location::current()``\  (DE 169)","Prague","",""
 "`3397 <https://wg21.link/LWG3397>`__","``ranges::basic_istream_view::iterator``\  should not provide ``iterator_category``\ ","Prague","","","|ranges|"
 "`3398 <https://wg21.link/LWG3398>`__","``tuple_element_t``\  is also wrong for ``const subrange``\ ","Prague","|Complete|","14.0","|ranges|"
 "`3446 <https://wg21.link/LWG3446>`__","``indirectly_readable_traits``\ ambiguity for types with both ``value_type``\ and ``element_type``\ ","November virtual meeting","|Complete|","13.0"

libcxx/include/CMakeLists.txt

set(files
   __iterator/insert_iterator.h
   __iterator/istream_iterator.h
   __iterator/istreambuf_iterator.h
   __iterator/iter_move.h
   __iterator/iter_swap.h
   __iterator/iterator.h
   __iterator/iterator_traits.h
   __iterator/move_iterator.h
+  __iterator/move_sentinel.h
   __iterator/next.h
   __iterator/ostream_iterator.h
   __iterator/ostreambuf_iterator.h
   __iterator/prev.h
   __iterator/projected.h
   __iterator/readable_traits.h
   __iterator/reverse_access.h
   __iterator/reverse_iterator.h

libcxx/include/__iterator/move_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___ITERATOR_MOVE_ITERATOR_H
 #define _LIBCPP___ITERATOR_MOVE_ITERATOR_H
 
+#include <__compare/compare_three_way_result.h>
+#include <__concepts/assignable.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/same_as.h>
 #include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iter_swap.h>
+#include <__iterator/move_sentinel.h>
+#include <__iterator/readable_traits.h>
+#include <__utility/move.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+template<class _Iter, class = void>
+struct __move_iter_category_base {};
+
+template<class _Iter>
+  requires requires { typename iterator_traits<_Iter>::iterator_category; }
+struct __move_iter_category_base<_Iter> {
+    using iterator_category = _If<
+        derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
+        random_access_iterator_tag,
+        typename iterator_traits<_Iter>::iterator_category
+    >;
+};
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
 template <class _Iter>
 class _LIBCPP_TEMPLATE_VIS move_iterator
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    : public __move_iter_category_base<_Iter>
+#endif
 {
 public:
-#if _LIBCPP_STD_VER > 17
-    typedef input_iterator_tag iterator_concept;
-#endif
-
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    using iterator_type = _Iter;
+    using iterator_concept = input_iterator_tag;
+    // iterator_category is inherited and not always present
+    using value_type = iter_value_t<_Iter>;
+    using difference_type = iter_difference_t<_Iter>;
+    using pointer = _Iter;
+    using reference = iter_rvalue_reference_t<_Iter>;
+#else
     typedef _Iter iterator_type;
     typedef _If<
         __is_cpp17_random_access_iterator<_Iter>::value,
         random_access_iterator_tag,
         typename iterator_traits<_Iter>::iterator_category
-    >  iterator_category;
+    > iterator_category;
     typedef typename iterator_traits<iterator_type>::value_type value_type;
     typedef typename iterator_traits<iterator_type>::difference_type difference_type;
     typedef iterator_type pointer;
 
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename iterator_traits<iterator_type>::reference __reference;
     typedef typename conditional<
             is_reference<__reference>::value,
             typename remove_reference<__reference>::type&&,
             __reference
         >::type reference;
 #else
     typedef typename iterator_traits<iterator_type>::reference reference;
 #endif
 
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
-    move_iterator() : __current_() {}
+    explicit move_iterator(_Iter __i) : __current_(_VSTD::move(__i)) {}
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator() requires is_constructible_v<_Iter> : __current_() {}
+
+    template <class _Up>
+        requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
+#else
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
-    explicit move_iterator(_Iter __i) : __current_(__i) {}
+    move_iterator() : __current_() {}
 
     template <class _Up, class = __enable_if_t<
         !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value
     > >
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
+#endif
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    template <class _Up>
+        requires (!_IsSame<_Up, _Iter>::value) &&
+                 convertible_to<const _Up&, _Iter> &&
+                 assignable_from<_Iter&, const _Up&>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    move_iterator& operator=(const move_iterator<_Up>& __u) {
+        __current_ = __u.base();
+        return *this;
+    }
+#else
     template <class _Up, class = __enable_if_t<
         !is_same<_Up, _Iter>::value &&
         is_convertible<const _Up&, _Iter>::value &&
         is_assignable<_Iter&, const _Up&>::value
     > >
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator=(const move_iterator<_Up>& __u) {
         __current_ = __u.base();
         return *this;
     }
+#endif
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const & noexcept { return __current_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return _VSTD::move(__current_); }
+#else
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     _Iter base() const { return __current_; }
+#endif
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    reference operator*() const { return ranges::iter_move(__current_); }
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reference operator[](difference_type __n) const { return ranges::iter_move(__current_ + __n); }
+#else
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator*() const { return static_cast<reference>(*__current_); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
-    pointer operator->() const { return __current_; }
+    pointer  operator->() const { return __current_; }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); }
+#endif
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator++() { ++__current_; return *this; }
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    auto operator++(int)
+        requires forward_iterator<_Iter>
+    {
+        move_iterator __tmp(*this); ++__current_; return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void operator++(int) { ++__current_; }
+#else
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; }
+#endif
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator--() { --__current_; return *this; }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator operator+(difference_type __n) const { return move_iterator(__current_ + __n); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator+=(difference_type __n) { __current_ += __n; return *this; }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator operator-(difference_type __n) const { return move_iterator(__current_ - __n); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator-=(difference_type __n) { __current_ -= __n; return *this; }
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+    template<sentinel_for<_Iter> _Sent>
+    friend _LIBCPP_HIDE_FROM_ABI constexpr
+    bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
+        requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
+    {
+        return __x.base() == __y.base();
+    }
+
+    template<sized_sentinel_for<_Iter> _Sent>
+    friend _LIBCPP_HIDE_FROM_ABI constexpr
+    iter_difference_t<_Iter> operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
+    {
+        return __x.base() - __y.base();
+    }
+
+    template<sized_sentinel_for<_Iter> _Sent>
+    friend _LIBCPP_HIDE_FROM_ABI constexpr
+    iter_difference_t<_Iter> operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
+    {
+        return __x.base() - __y.base();
+    }
+
+    friend _LIBCPP_HIDE_FROM_ABI constexpr
+    iter_rvalue_reference_t<_Iter> iter_move(const move_iterator& __i)
+        noexcept(noexcept(ranges::iter_move(__i.__current_)))
+    {
+        return ranges::iter_move(__i.__current_);
+    }
+
+    template<indirectly_swappable<_Iter> _It2>
+    friend _LIBCPP_HIDE_FROM_ABI constexpr
+    void iter_swap(const move_iterator& __x, const move_iterator<_It2>& __y)
+        noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
+    {
+        return ranges::iter_swap(__x.__current_, __y.__current_);
+    }
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
 private:
+    template<class _It2> friend class move_iterator;
+
     _Iter __current_;
 };
 
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {
     return __x.base() == __y.base();
 }
 
+#if _LIBCPP_STD_VER <= 17
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {
     return __x.base() != __y.base();
 }
+#endif // _LIBCPP_STD_VER <= 17
 
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {
     return __x.base() < __y.base();
 }
 

 
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {
     return __x.base() >= __y.base();
 }
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+template <class _Iter1, class _Iter2>
+inline _LIBCPP_HIDE_FROM_ABI constexpr
+auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
+    -> compare_three_way_result_t<_Iter1, _Iter2>
+{
+    return __x.base() <=> __y.base();
+}
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
     -> decltype(__x.base() - __y.base())
 {
     return __x.base() - __y.base();
 }
 #else
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_HIDE_FROM_ABI
 typename move_iterator<_Iter1>::difference_type
 operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {
     return __x.base() - __y.base();
 }
 #endif
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+template <class _Iter>
+inline _LIBCPP_HIDE_FROM_ABI constexpr
+move_iterator<_Iter> operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x)
+    requires requires { { __x.base() + __n } -> same_as<_Iter>; }
+{
+    return __x + __n;
+}
+#else
 template <class _Iter>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 move_iterator<_Iter>
 operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
 {
     return move_iterator<_Iter>(__x.base() + __n);
 }
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 template <class _Iter>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 move_iterator<_Iter>
 make_move_iterator(_Iter __i)
 {
-    return move_iterator<_Iter>(__i);
+    return move_iterator<_Iter>(_VSTD::move(__i));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H

libcxx/include/__iterator/move_sentinel.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___ITERATOR_MOVE_SENTINEL_H
+#define _LIBCPP___ITERATOR_MOVE_SENTINEL_H
+
+#include <__concepts/assignable.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/semiregular.h>
+#include <__config>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template <semiregular _Sent>
+class _LIBCPP_TEMPLATE_VIS move_sentinel
+{
+public:
+  _LIBCPP_HIDE_FROM_ABI
+  move_sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  explicit move_sentinel(_Sent __s) : __last_(_VSTD::move(__s)) {}
+
+  template <class _S2>
+    requires convertible_to<const _S2&, _Sent>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  move_sentinel(const move_sentinel<_S2>& __s) : __last_(__s.__last_) {}
+
+  template <class _S2>
+    requires assignable_from<_Sent, const _S2&>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  move_sentinel& operator=(const move_sentinel<_S2>& __s)
+    { __last_ = __s.__last_; return *this; }
+
+  constexpr _Sent base() const { return __last_; }
+
+private:
+    _Sent __last_;
+};
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_MOVE_SENTINEL_H

libcxx/include/iterator

 #include <__iterator/insert_iterator.h>
 #include <__iterator/istream_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
+#include <__iterator/move_sentinel.h>
 #include <__iterator/next.h>
 #include <__iterator/ostream_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
 #include <__iterator/prev.h>
 #include <__iterator/projected.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_access.h>
 #include <__iterator/reverse_iterator.h>

libcxx/include/module.modulemap

module __iterator {
       module insert_iterator       { private header "__iterator/insert_iterator.h" }
       module istream_iterator      { private header "__iterator/istream_iterator.h" }
       module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
       module iter_move             { private header "__iterator/iter_move.h" }
       module iter_swap             { private header "__iterator/iter_swap.h" }
       module iterator              { private header "__iterator/iterator.h" }
       module iterator_traits       { private header "__iterator/iterator_traits.h" }
       module move_iterator         { private header "__iterator/move_iterator.h" }
+      module move_sentinel         { private header "__iterator/move_sentinel.h" }
       module next                  {
         private header "__iterator/next.h"
         export __function_like
       }
       module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
       module ostreambuf_iterator   { private header "__iterator/ostreambuf_iterator.h" }
       module prev                  {
         private header "__iterator/prev.h"

libcxx/test/libcxx/diagnostics/detail.headers/iterator/move_sentinel.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__iterator/move_sentinel.h'}}
+#include <__iterator/move_sentinel.h>

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp

 // move_iterator
 
 // explicit move_iterator(Iter i);
 //
 //  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>
-void
-test(It i)
+TEST_CONSTEXPR_CXX17 bool test()
 {
-    std::move_iterator<It> r(i);
-    assert(r.base() == i);
+  static_assert( std::is_constructible<std::move_iterator<It>, const It&>::value, "");
+  static_assert( std::is_constructible<std::move_iterator<It>, It&&>::value, "");
+  static_assert(!std::is_convertible<const It&, std::move_iterator<It>>::value, "");
+  static_assert(!std::is_convertible<It&&, std::move_iterator<It>>::value, "");
+
+  char s[] = "123";
+  {
+    It it = It(s);
+    std::move_iterator<It> r(it);
+    assert(base(r.base()) == s);
+  }
+  {
+    It it = It(s);
+    std::move_iterator<It> r(std::move(it));
+    assert(base(r.base()) == s);
+  }
+  return true;
 }
 
-int main(int, char**)
+template <class It>
+TEST_CONSTEXPR_CXX17 bool test_moveonly()
 {
-    char s[] = "123";
-    test(cpp17_input_iterator<char*>(s));
-    test(forward_iterator<char*>(s));
-    test(bidirectional_iterator<char*>(s));
-    test(random_access_iterator<char*>(s));
-    test(s);
+  static_assert(!std::is_constructible<std::move_iterator<It>, const It&>::value, "");
+  static_assert( std::is_constructible<std::move_iterator<It>, It&&>::value, "");
+  static_assert(!std::is_convertible<const It&, std::move_iterator<It>>::value, "");
+  static_assert(!std::is_convertible<It&&, std::move_iterator<It>>::value, "");
 
-#if TEST_STD_VER > 14
-    {
-    constexpr const char *p = "123456789";
-    constexpr std::move_iterator<const char *> it(p);
-    static_assert(it.base() == p);
-    }
+  char s[] = "123";
+    It it = It(s);
+    std::move_iterator<It> r(std::move(it));
+    assert(base(r.base()) == s);
+  }
+  return true;
+
+int main(int, char**)
+{
+  test<cpp17_input_iterator<char*> >();
+  test<forward_iterator<char*> >();
+  test<bidirectional_iterator<char*> >();
+  test<random_access_iterator<char*> >();
+  test<char*>();
+  test<const char*>();
+
+#if TEST_STD_VER > 14
+  static_assert(test<cpp17_input_iterator<char*>>());
+  static_assert(test<forward_iterator<char*>>());
+  static_assert(test<bidirectional_iterator<char*>>());
+  static_assert(test<random_access_iterator<char*>>());
+  static_assert(test<char*>());
+  static_assert(test<const char*>());
+#endif
+
+#if TEST_STD_VER > 17
+  test<contiguous_iterator<char*>>();
+  test_moveonly<cpp20_input_iterator<char*>>();
+  static_assert(test<contiguous_iterator<char*>>());
+  static_assert(test_moveonly<cpp20_input_iterator<char*>>());
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // move_iterator
 
 // pointer operator->() const;
 //
 //  constexpr in C++17
+//  removed in C++20
 
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 
-template <class It>
-void
-test(It i)
+#if TEST_STD_VER > 17
+template <class T>
+concept HasArrow = requires (T t) {
+    t.operator->();
+};
+static_assert(!HasArrow<std::move_iterator<int*>>);
+static_assert(!HasArrow<std::move_iterator<int*>&>);
+static_assert(!HasArrow<std::move_iterator<int*>&&>);
+#endif // TEST_STD_VER > 17
+
+TEST_CONSTEXPR_CXX17 bool test()
 {
-    std::move_iterator<It> r(i);
-    assert(r.operator->() == i);
+#if TEST_STD_VER <= 17
+    char a[] = "123456789";
+    std::move_iterator<char *> it1 = std::make_move_iterator(a);
+    std::move_iterator<char *> it2 = std::make_move_iterator(a + 1);
+    assert(it1.operator->() == a);
+    assert(it2.operator->() == a + 1);
+#endif
+    return true;
 }
 
 int main(int, char**)
 {
-    char s[] = "123";
-    test(s);
-
+    test();
 #if TEST_STD_VER > 14
-    {
-    constexpr const char *p = "123456789";
-    typedef std::move_iterator<const char *> MI;
-    constexpr MI it1 = std::make_move_iterator(p);
-    constexpr MI it2 = std::make_move_iterator(p+1);
-    static_assert(it1.operator->() == p, "");
-    static_assert(it2.operator->() == p + 1, "");
-    }
+    static_assert(test());
 #endif
 
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp

struct ToIter {
     TEST_CONSTEXPR_CXX17 ToIter &operator=(char *src) {
         m_value = src;
         return *this;
     }
     TEST_CONSTEXPR_CXX17 ToIter &operator=(const ToIter &src) {
         m_value = src.m_value;
         return *this;
     }
+
+    char& operator*() const;
+
     char *m_value;
 };
 
 TEST_CONSTEXPR_CXX17 bool test_conv_assign()
 {
     char c = '\0';
     char *fi = &c;
     const std::move_iterator<char *> move_fi(fi);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // move_iterator
 
 #include <iterator>
 
-using iterator = std::move_iterator<int*>;
+#include "test_iterators.h"
+#include "test_macros.h"
+
+void test()
+{
+  {
+    using iterator = std::move_iterator<cpp17_input_iterator<int*>>;
 
-static_assert(std::input_iterator<iterator>);
+    LIBCPP_STATIC_ASSERT(!std::default_initializable<iterator>);
+    static_assert( std::copyable<iterator>);
+    static_assert( std::input_iterator<iterator>);
     static_assert(!std::forward_iterator<iterator>);
+    static_assert(!std::sentinel_for<iterator, iterator>); // not copyable
+    static_assert(!std::sized_sentinel_for<iterator, iterator>);
+    static_assert( std::indirectly_readable<iterator>);
     static_assert(!std::indirectly_writable<iterator, int>);
-static_assert(std::incrementable<iterator>);
-static_assert(std::sentinel_for<iterator, iterator>);
-static_assert(std::sized_sentinel_for<iterator, iterator>);
-static_assert(!std::indirectly_movable<int*, iterator>);
-static_assert(!std::indirectly_movable_storable<int*, iterator>);
-static_assert(!std::indirectly_swappable<iterator, iterator>);
+    static_assert( std::indirectly_swappable<iterator, iterator>);
+  }
+  {
+    using iterator = std::move_iterator<cpp20_input_iterator<int*>>;
+
+    LIBCPP_STATIC_ASSERT(!std::default_initializable<iterator>);
+    static_assert(!std::copyable<iterator>);
+    static_assert( std::input_iterator<iterator>);
+    static_assert(!std::forward_iterator<iterator>);
+    static_assert(!std::sentinel_for<iterator, iterator>); // not copyable
+    static_assert(!std::sized_sentinel_for<iterator, iterator>);
+    static_assert( std::indirectly_readable<iterator>);
+    static_assert(!std::indirectly_writable<iterator, int>);
+    static_assert( std::indirectly_swappable<iterator, iterator>);
+  }
+  {
+    using iterator = std::move_iterator<forward_iterator<int*>>;
+
+    static_assert( std::default_initializable<iterator>);
+    static_assert( std::copyable<iterator>);
+    static_assert( std::input_iterator<iterator>);
+    static_assert(!std::forward_iterator<iterator>);
+    static_assert( std::sentinel_for<iterator, iterator>);
+    static_assert(!std::sized_sentinel_for<iterator, iterator>);
+    static_assert( std::indirectly_readable<iterator>);
+    static_assert(!std::indirectly_writable<iterator, int>);
+    static_assert( std::indirectly_swappable<iterator, iterator>);
+  }
+  {
+    using iterator = std::move_iterator<bidirectional_iterator<int*>>;
+
+    static_assert( std::default_initializable<iterator>);
+    static_assert( std::copyable<iterator>);
+    static_assert( std::input_iterator<iterator>);
+    static_assert(!std::forward_iterator<iterator>);
+    static_assert( std::sentinel_for<iterator, iterator>);
+    static_assert(!std::sized_sentinel_for<iterator, iterator>);
+    static_assert( std::indirectly_readable<iterator>);
+    static_assert(!std::indirectly_writable<iterator, int>);
+    static_assert( std::indirectly_swappable<iterator, iterator>);
+  }
+  {
+    using iterator = std::move_iterator<random_access_iterator<int*>>;
+
+    static_assert( std::default_initializable<iterator>);
+    static_assert( std::copyable<iterator>);
+    static_assert( std::input_iterator<iterator>);
+    static_assert(!std::forward_iterator<iterator>);
+    static_assert( std::sentinel_for<iterator, iterator>);
+    static_assert( std::sized_sentinel_for<iterator, iterator>);
+    static_assert( std::indirectly_readable<iterator>);
+    static_assert(!std::indirectly_writable<iterator, int>);
+    static_assert( std::indirectly_swappable<iterator, iterator>);
+  }
+  {
+    using iterator = std::move_iterator<contiguous_iterator<int*>>;
+
+    static_assert( std::default_initializable<iterator>);
+    static_assert( std::copyable<iterator>);
+    static_assert( std::input_iterator<iterator>);
+    static_assert(!std::forward_iterator<iterator>);
+    static_assert( std::sentinel_for<iterator, iterator>);
+    static_assert( std::sized_sentinel_for<iterator, iterator>);
+    static_assert( std::indirectly_readable<iterator>);
+    static_assert(!std::indirectly_writable<iterator, int>);
+    static_assert( std::indirectly_swappable<iterator, iterator>);
+  }
+  {
+    using iterator = std::move_iterator<int*>;
+
+    static_assert( std::default_initializable<iterator>);
+    static_assert( std::copyable<iterator>);
+    static_assert( std::input_iterator<iterator>);
+    static_assert(!std::forward_iterator<iterator>);
+    static_assert( std::sentinel_for<iterator, iterator>);
+    static_assert( std::sized_sentinel_for<iterator, iterator>);
+    static_assert( std::indirectly_readable<iterator>);
+    static_assert(!std::indirectly_writable<iterator, int>);
+    static_assert( std::indirectly_swappable<iterator, iterator>);
+  }
+}