[libc++] implement move_iterator<T*> should be a random access iterator

[Mordante]

Summary

Initial patch for implementing https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2520r0.html

[phyBrackets]

I'm not sure about, where to look for testing of it or need to create new tests ?

[philnik]

In D135248#3836234, @phyBrackets wrote:

I'm not sure about, where to look for testing of it or need to create new tests ?

There should be a test in libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator.

Please go through https://libcxx.llvm.org/Contributing.html#pre-commit-check-list again and check that you did everything.

libcxx/include/__iterator/move_iterator.h

72

You can make this function consteval. IMO Something like __get_iterator_concept() would be clearer, since iterator tags are used for both iterator_category and iterator_concept, but this function is only correct for iterator_concept. You also have to guard the functions with _LIBCPP_STD_VER >= 20.

73

The paper is referencing C++20 iterators, not C++17 iterators.

77

You have to check bidirectional_iterator before forward_iterator, since random_access_iterator is a subset of bidirectional_iterator is a subset of forward_iterator.

[huixie90]

Thanks for the patch. Please take a look at the test
libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
and update it, and/or add new tests

Another question is it this paper a DR or not? do we want to DR back to C++20's or just for C++23?

libcxx/include/__iterator/move_iterator.h

72

either add _LIBCPP_HIDE_FROM_ABI macro, or change the function to consteval

73–77

According to p2520r0, these checks should check against C++20 concept rather than C++17 concepts

if constexpr (random_access_iterator<_Iter>){
 // ...
} else if constexpr (bidirectional_iterator<_Iter>) {
 // ...
} else if constexpr ( forward_iterator<_Iter>) {

And then the function should be guarded against C++ 20

75

forward_iterator check should come after bidirectional_iterator

[phyBrackets]

libcxx/include/__iterator/move_iterator.h

72

doesn't _LIBCPP_STD_VER > 17 means the same?

[philnik]

libcxx/include/__iterator/move_iterator.h

72

Yes, but you didn't guard the function at all. We also decided to switch to _LIBCPP_STD_VER >= xy in new code.

[phyBrackets]

Hey @philnik , could you tell me about the tests? does changes in the type.pass.cpp looks correct? Although I tried running the test using llvm-lit but got the failure on iterator_concept_conformance.compile.pass.cpp and type.pass.cpp.

[phyBrackets]

Re-uploading the patch

[phyBrackets]

Updating the patch after rebasing

[ldionne]

This patch isn't on top of main, is it?

[phyBrackets]

rebase the changes on top of main

[EricWF]

libcxx/include/__iterator/move_iterator.h

71

As others have said _LIBCPP_STD_VER > 20

72

Yeah, this doesn't need _LIBCPP_HIDE_FROM_ABI, but if you want it for consistency...

In fact we don't need to hide 70% of the stuff we hide, but /shrug

72

Reserved names are __lower_case_after_two_underscores or _UpperCaseAfterOneUnderscore.

You either need two underscores or a single underscore followed by a capital letter.

84

Why did this stuff get moved?

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

144–145

This is the correct behavior for C++20, the change only applies to C++2b.
So don't change these tests, but instead add more tests for the new C++20 behavior.

[phyBrackets]

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

144–145

shouldn't it be for _LIBCPP_STD_VER >= 20 ?

[phyBrackets]

update the revision with few changes for the correct version

[phyBrackets]

libcxx/include/__iterator/move_iterator.h

84

__get_iterator_concept and _Iter __current_ both of them are the private members, so I thought we can place them together. but yeah i guess it's fine to place separately.

[phyBrackets]

Hey @EricWF , could you please take a look at this patch, i guess there are some tests which got affected by this . I'm not sure if i need to update them for passing the CI?

[EricWF]

In D135248#3919379, @phyBrackets wrote:

Hey @EricWF , could you please take a look at this patch, i guess there are some tests which got affected by this . I'm not sure if i need to update them for passing the CI?

It looks to me that there are still issues with this patch changing the implementation prior to C++20. Please fix that (see the existing inline comments).

[phyBrackets]

Correctly places the macros.

[phyBrackets]

It still failing on the ranges.min.max.pass.cpp, we need to guard that too for passing the CI. Or Is there any other work around?

[fsb4000]

Hi.

I started https://reviews.llvm.org/D142841 because I missed your revision.

I abadonned my revision.

I think you need to do such changes that I did in:

libcxx/docs/ReleaseNotes.rst

libcxx/docs/Status/Cxx2bPapers.csv

libcxx/include/iterator

Feel free to use my revision.

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

19

[fsb4000]

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax.pass.cpp failed because of a bug in our ranges::minmax implementation.

I will prepare a fix in few minutes.

[fsb4000]

I've created https://reviews.llvm.org/D142864

[phyBrackets]

For an update on the patch, this patch is currently for _LIBCPP_STD_VER > 20 , and tests cases fixed accordingly to pass the CI , if there is anything that needs to be change, let me know!

[philnik]

Please remove the format-only changes. This makes it incredibly hard to see what you actually changed.

[phyBrackets]

Hey @philnik , sorry for the format changes but this is what i can do best for now , not sure about the removing all the format changes!

[phyBrackets]

for ignoring the whitespace changes used git diff -b that's why it's failing for now but will change it once you review the basic structure of the patch

[fsb4000]

I pushed my commit: https://github.com/llvm/llvm-project/commit/0a0d58f5465a2524ec9ed10ed0bb277cab5a180c

Now you have to rebase your patch and then you don't need

#if TEST_STD_VER <= 20
...
#endif

in ranges.minmax.pass.cpp

Actually that code block was removed at all.

[phyBrackets]

Thanks @fsb4000

[fsb4000]

patch application failed

How did you create your diff?
I create my diffs like this:

git diff -U999999 main > 1.txt

and then I upload 1.txt

[phyBrackets]

In D135248#4135268, @fsb4000 wrote:

patch application failed

How did you create your diff?
I create my diffs like this:

git diff -U999999 main > 1.txt

and then I upload 1.txt

Thanks @fsb4000 , missed the main

[fsb4000]

Build 327893: pre-merge checks patch application failed

Could you upload your branch to your github? (https://github.com/phyBrackets/llvm-project-1)

I will try to generate the correct diff.

[fsb4000]

Thanks, I see something really cursed happened.

https://github.com/phyBrackets/llvm-project-1/tree/newB

This branch is 2972 commits ahead, 3044 commits behind llvm:main.

You could try upload my 1.txt file as a revision, maybe we can progress this way...

1.txt349 KBDownload

[fsb4000]

libcxx/docs/FeatureTestMacroTable.rst

263

CI failed because extra space there

[fsb4000]

Microsoft STL treats this paper as a DR and I agree with Casey Carter that the code breakage will be minimal because the move_iterators are still input iterators in C++20.

libc++ already gives more guaranties for things than the standard says, for example for the 'std::filesystem::path::iterator'.

from https://github.com/microsoft/STL/pull/2958#discussion_r931710527

This paper is effectively an admission that artificially depressing the category of move_iterator was a failed experiment. There's no value in preserving the undesired behavior in C++20 mode, and we suspect the potential for breakage to be very small given that move_iterators are still input iterators even if they now sometimes satisfy stronger concepts. We therefore decided to implement this change in all pertinent language modes.

What do other reviewers think?

[ldionne]

@jwakely Does libstdc++ implement P2520R0 in C++20 as a DR too?

My desire here is to align the various implementations.

[jwakely]

In D135248#4155762, @ldionne wrote:

@jwakely Does libstdc++ implement P2520R0 in C++20 as a DR too?

We didn't implement this yet, but Casey's position makes sense to me.

I'm happy to do this for C++20 if you are doing it.

[phyBrackets]

Hey @fsb4000 @ldionne , Let me know if it's fine to commit this. I'll do it. Thanks!

[philnik]

LGTM % comments.

libcxx/docs/ReleaseNotes.rst

40–41 ↗

(On Diff #500594)

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

102

[phyBrackets]

Hey @philnik , I'm not sure about, can we land this now?

[philnik]

In D135248#4161887, @phyBrackets wrote:

Hey @philnik , I'm not sure about, can we land this now?

With the remaining comments address we can land it.

[phyBrackets]

cool, Thanks!

[phyBrackets]

https://github.com/llvm/llvm-project/commit/813e1da9749a5d2d604198cf534f750c842eda22 , commited by me only!

[ldionne]

In D135248#4156007, @jwakely wrote:

In D135248#4155762, @ldionne wrote:

@jwakely Does libstdc++ implement P2520R0 in C++20 as a DR too?

We didn't implement this yet, but Casey's position makes sense to me.

I'm happy to do this for C++20 if you are doing it.

Ok, let's all do it then.

@phyBrackets Can you please add the note in another PR? This was committed sooner than I expected.

libcxx/docs/Status/Cxx2bPapers.csv

87 ↗

(On Diff #500594)

Please add a note that we implement P2520R0 as a DR in C++20 as well.

[phyBrackets]

Hey @ldionne, Here is the follow up revision https://reviews.llvm.org/D145087

[Mordante]

In D135248#4162128, @phyBrackets wrote:

https://github.com/llvm/llvm-project/commit/813e1da9749a5d2d604198cf534f750c842eda22 , commited by me only!

FYI it seems that commit message does have a slightly different

Differntial Revision- https://reviews.llvm.org/D135248

part in the message. Please use the proper form next time, then Phabricator will automatically close the revision.

Can you close it manually?

[phyBrackets]

Hey @Mordante , Sorry for it! I'm not sure how to close it manually, I tried Add Action here but I cannot see any option for Closing the revision ?

[Mordante]

In D135248#4162409, @phyBrackets wrote:

Hey @Mordante , Sorry for it! I'm not sure how to close it manually, I tried Add Action here but I cannot see any option for Closing the revision ?

Odd, I'll try it by taking over the patch.

[Mordante]

Odd I don't see close too, I'll mark it as abandoned, that way it will be marked as closed.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_jthread``                             *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_latch``                               ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_list_remove_return_type``             ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_math_constants``                      ``201907L``
     ------------------------------------------------- -----------------
+    ``__cpp_lib_move_iterator_concept``               ``202207L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_polymorphic_allocator``               ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges``                              ``202106L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_remove_cvref``                        ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_semaphore``                           ``201907L``
     ------------------------------------------------- -----------------
.. table:: Current Status
     ``__cpp_lib_expected``                            ``202202L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_forward_like``                        ``202207L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_invoke_r``                            ``202106L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_move_iterator_concept``               ``202207L``
-    ------------------------------------------------- -----------------
     ``__cpp_lib_move_only_function``                  *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_optional``                            ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_out_ptr``                             *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                        *unimplemented*
     ------------------------------------------------- -----------------

libcxx/include/__iterator/move_iterator.h

 #define _LIBCPP___ITERATOR_MOVE_ITERATOR_H
 
 #include <__compare/compare_three_way_result.h>
 #include <__compare/three_way_comparable.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/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_sentinel.h>
 #include <__iterator/readable_traits.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/declval.h>
 #include <__utility/move.h>
 
-#include <__config>
-
-#include <__config>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-<<<<<<< HEAD
 #if _LIBCPP_STD_VER >= 20
 template<class _Iter, class = void>
-=======
-#if _LIBCPP_STD_VER > 17
-template <class _Iter, class = void>
->>>>>>> 15527f7e112d (move_iterator updates)
 struct __move_iter_category_base {};
 
-template <class _Iter>
-template <class _Iter>
+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>;
-  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>;
+    using iterator_category = _If<
+        derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
+        typename iterator_traits<_Iter>::iterator_category
+    >;
 };
 
-template <class _Iter, class _Sent>
-template <class _Iter, class _Sent>
+template<class _Iter, class _Sent>
 concept __move_iter_comparable = requires {
     { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
-  { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
 };
 #endif // _LIBCPP_STD_VER >= 20
 
 template <class _Iter>
 class _LIBCPP_TEMPLATE_VIS move_iterator
 #if _LIBCPP_STD_VER >= 20
     : public __move_iter_category_base<_Iter>
 #endif
 {
-#if _LIBCPP_STD_VER > 17
-
-#if _LIBCPP_STD_VER > 17
-
-public:
-  using iterator_type = _Iter;
-  // 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>;
-#  if _LIBCPP_STD_VER > 20
-
+  #if _LIBCPP_STD_VER >= 20
 private:
-  static consteval auto __get_iterator_concept() {
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr auto __get_iter_concept() {
         if constexpr (random_access_iterator<_Iter>) {
             return random_access_iterator_tag{};
         } else if constexpr (bidirectional_iterator<_Iter>) {
             return bidirectional_iterator_tag{};
         } else if constexpr (forward_iterator<_Iter>) {
             return forward_iterator_tag{};
         } else {
             return input_iterator_tag{};
         }
     }
+#endif // _LIBCPP_STD_VER >= 20
 
 public:
-  using iterator_concept = decltype(__get_iterator_concept());
-#  endif //  _LIBCPP_STD_VER > 20
+#if _LIBCPP_STD_VER >= 20
     using iterator_type = _Iter;
+    using iterator_concept = decltype(__get_iter_concept());
     // iterator_category is inherited and not always present
-  using value_type      = iter_value_t<_Iter>;
+    using value_type = iter_value_t<_Iter>;
     using difference_type = iter_difference_t<_Iter>;
-  using pointer         = _Iter;
-  using reference       = iter_rvalue_reference_t<_Iter>;
-#  if _LIBCPP_STD_VER > 20
-
-private:
-  static consteval auto __get_iterator_concept() {
-    if constexpr (random_access_iterator<_Iter>) {
-      return random_access_iterator_tag{};
-    } else if constexpr (bidirectional_iterator<_Iter>) {
-      return bidirectional_iterator_tag{};
-    } else if constexpr (forward_iterator<_Iter>) {
-      return forward_iterator_tag{};
-    } else {
-      return input_iterator_tag{};
-    }
-  }
-
-public:
-  using iterator_concept = decltype(__get_iterator_concept());
-#  endif //  _LIBCPP_STD_VER > 20
+    using pointer = _Iter;
+    using reference = iter_rvalue_reference_t<_Iter>;
 #else
-
-public:
     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;
-  typedef typename iterator_traits<iterator_type>::value_type value_type;
-  typedef typename iterator_traits<iterator_type>::difference_type difference_type;
-  typedef iterator_type pointer;
-
-public:
-  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;
+    typedef _If<
+        __is_cpp17_random_access_iterator<_Iter>::value,
+        typename iterator_traits<_Iter>::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;
 
     typedef typename iterator_traits<iterator_type>::reference __reference;
-  typedef
-      typename conditional<is_reference<__reference>::value, __libcpp_remove_reference_t<__reference>&&, __reference>::
-          type reference;
-#endif // _LIBCPP_STD_VER > 17
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator++() {
-    ++__current_;
-    return *this;
-  }
-
-  _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pointer operator->() const {
-    return __current_;
-  }
-
-#if _LIBCPP_STD_VER > 17
-  _LIBCPP_HIDE_FROM_ABI constexpr 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()) {}
-
-  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;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const& noexcept { return __current_; }
-  _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return std::move(__current_); }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator*() const { return ranges::iter_move(__current_); }
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](difference_type __n) const {
-    return ranges::iter_move(__current_ + __n);
-  }
-
-  _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_SINCE_CXX17 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_SINCE_CXX17 move_iterator(const move_iterator<_Up>& __u)
-      : __current_(__u.base()) {}
-
-  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_SINCE_CXX17 move_iterator& operator=(const move_iterator<_Up>& __u) {
-    __current_ = __u.base();
-    return *this;
-  }
+    typedef typename conditional<
+            is_reference<__reference>::value,
+            __libcpp_remove_reference_t<__reference>&&,
+            __reference
+        >::type reference;
+#endif // _LIBCPP_STD_VER >= 20
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter base() const { return __current_; }
-  typedef typename iterator_traits<iterator_type>::reference __reference;
-  typedef
-      typename conditional<is_reference<__reference>::value, __libcpp_remove_reference_t<__reference>&&, __reference>::
-          type reference;
-#endif // _LIBCPP_STD_VER > 17
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+    explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator++() {
-    ++__current_;
-    return *this;
-  }
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+    move_iterator& operator++() { ++__current_; return *this; }
 
-  _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pointer operator->() const {
-    return __current_;
-  }
+    _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+    pointer operator->() const { return __current_; }
 
-#if _LIBCPP_STD_VER > 17
-  _LIBCPP_HIDE_FROM_ABI constexpr move_iterator() requires is_constructible_v<_Iter> : __current_() {}
+#if _LIBCPP_STD_VER >= 20
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    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()) {}
+        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()) {}
 
     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) {
+        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;
     }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const& noexcept { return __current_; }
+    _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const & noexcept { return __current_; }
     _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return std::move(__current_); }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator*() const { return ranges::iter_move(__current_); }
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](difference_type __n) const {
-    return ranges::iter_move(__current_ + __n);
-  }
-
-  _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_SINCE_CXX17 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_SINCE_CXX17 move_iterator(const move_iterator<_Up>& __u)
-      : __current_(__u.base()) {}
-
-  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_SINCE_CXX17 move_iterator& operator=(const move_iterator<_Up>& __u) {
-    __current_ = __u.base();
-    return *this;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter base() const { return __current_; }
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator*() const {
-    return static_cast<reference>(*__current_);
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](difference_type __n) const {
-    return static_cast<reference>(__current_[__n]);
-  }
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator++(int) {
-    move_iterator __tmp(*this);
-    ++__current_;
-    return __tmp;
-  }
-#endif // _LIBCPP_STD_VER > 17
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator--() {
-    --__current_;
-    return *this;
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator--(int) {
-    move_iterator __tmp(*this);
-    --__current_;
-    return __tmp;
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator+(difference_type __n) const {
-    return move_iterator(__current_ + __n);
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator+=(difference_type __n) {
-    __current_ += __n;
-    return *this;
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator-(difference_type __n) const {
-    return move_iterator(__current_ - __n);
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator-=(difference_type __n) {
-    __current_ -= __n;
-    return *this;
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator--() {
-    --__current_;
-    return *this;
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator--(int) {
-    move_iterator __tmp(*this);
-    --__current_;
-    return __tmp;
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator+(difference_type __n) const {
-    return move_iterator(__current_ + __n);
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator+=(difference_type __n) {
-    __current_ += __n;
-    return *this;
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator-(difference_type __n) const {
-    return move_iterator(__current_ - __n);
-  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator-=(difference_type __n) {
-    __current_ -= __n;
-    return *this;
-  }
-
-<<<<<<< HEAD
-#if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator() requires is_constructible_v<_Iter> : __current_() {}
-=======
-#if _LIBCPP_STD_VER > 17
-  template <sentinel_for<_Iter> _Sent>
-  friend _LIBCPP_HIDE_FROM_ABI constexpr bool
-  operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y) requires __move_iter_comparable<_Iter, _Sent> {
-    return __x.base() == __y.base();
-  }
->>>>>>> 15527f7e112d (move_iterator updates)
-
-  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_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();
-  }
-  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_);
-  }
-  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_);
-  }
-
-<<<<<<< HEAD
     _LIBCPP_HIDE_FROM_ABI constexpr
     reference operator*() const { return ranges::iter_move(__current_); }
     _LIBCPP_HIDE_FROM_ABI constexpr
     reference operator[](difference_type __n) const { return ranges::iter_move(__current_ + __n); }
 
     _LIBCPP_HIDE_FROM_ABI constexpr
     auto operator++(int)
         requires forward_iterator<_Iter>
#if _LIBCPP_STD_VER >= 20
     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 >= 20
-=======
-  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
->>>>>>> 15527f7e112d (move_iterator updates)
 
 private:
-  template <class _It2>
-  friend class move_iterator;
-  template <class _It2>
-  friend class move_iterator;
+    template<class _It2> friend class move_iterator;
 
     _Iter __current_;
-  _Iter __current_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_iterator);
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
-operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
-  return __x.base() == __y.base();
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
-operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+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_SINCE_CXX17 bool
-operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
-  return __x.base() != __y.base();
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
-operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+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_SINCE_CXX17 bool
-operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
-  return __x.base() < __y.base();
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
-operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+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_SINCE_CXX17 bool
-operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
-  return __x.base() > __y.base();
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
-operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+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_SINCE_CXX17 bool
-operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
-  return __x.base() <= __y.base();
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
-operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+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_SINCE_CXX17 bool
-operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
-  return __x.base() >= __y.base();
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
-operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
+{
     return __x.base() >= __y.base();
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Iter1, three_way_comparable_with<_Iter1> _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();
-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> {
+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 >= 20
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto
-operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) -> decltype(__x.base() - __y.base()) {
-  return __x.base() - __y.base();
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto
-operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) -> decltype(__x.base() - __y.base()) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+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();
-inline _LIBCPP_HIDE_FROM_ABI typename move_iterator<_Iter1>::difference_type
-operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+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 // !_LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER >= 20
 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>;
-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>;
+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;
 }
-{ return __x + __n; }
-{ return __x + __n; }
 #else
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter>
-operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x) {
-  return move_iterator<_Iter>(__x.base() + __n);
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter>
-operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+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 >= 20
 
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter> make_move_iterator(_Iter __i) {
-  return move_iterator<_Iter>(std::move(__i));
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter> make_move_iterator(_Iter __i) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
+move_iterator<_Iter>
+make_move_iterator(_Iter __i)
+{
     return move_iterator<_Iter>(std::move(__i));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H

libcxx/include/iterator

 insert_iterator<Container> inserter(Container& x, typename Container::iterator i);  // until C++20
 template <class Container>
 constexpr insert_iterator<Container> inserter(Container& x, ranges::iterator_t<Container> i);  // since C++20
 
 template <class Iterator>
 class move_iterator {
 public:
     using iterator_type     = Iterator;
-    using iterator_concept  = input_iterator_tag; // From C++20
+    using iterator_concept  = see below; // From C++20
     using iterator_category = see below; // not always present starting from C++20
     using value_type        = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type
     using difference_type   = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type;
     using pointer           = Iterator;
     using reference         = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&&
 
     constexpr move_iterator();  // all the constexprs are in C++17
     constexpr explicit move_iterator(Iterator i);

libcxx/include/version

 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_jthread                            201911L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
+# define __cpp_lib_move_iterator_concept                202207L
 # define __cpp_lib_polymorphic_allocator                201902L
 # define __cpp_lib_ranges                               202106L
 # define __cpp_lib_remove_cvref                         201711L
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # undef  __cpp_lib_shared_ptr_arrays
 # define __cpp_lib_shared_ptr_arrays                    201707L

 // # define __cpp_lib_constexpr_cmath                      202202L
 # undef  __cpp_lib_constexpr_memory
 # define __cpp_lib_constexpr_memory                     202202L
 # define __cpp_lib_constexpr_typeinfo                   202106L
 # define __cpp_lib_expected                             202202L
 # define __cpp_lib_forward_like                         202207L
 # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
-# define __cpp_lib_move_iterator_concept                202207L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
 // # define __cpp_lib_ranges_chunk                         202202L
 // # define __cpp_lib_ranges_chunk_by                      202202L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L

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

 
 // move_iterator
 
 #include <iterator>
 
 #include "test_iterators.h"
 #include "test_macros.h"
 
-#if TEST_STD_VER <= 20
+#if TEST_STD_VER < 20
 
 void test() {
   {
     using iterator = std::move_iterator<cpp17_input_iterator<int*>>;
 
     LIBCPP_STATIC_ASSERT(!std::default_initializable<iterator>);
     static_assert(std::copyable<iterator>);
     static_assert(std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_specializations.pass.cpp

 // move_iterator
 
 #include <iterator>
 
 #include "test_iterators.h"
 #include "test_macros.h"
 
 // Tests for move_iterator specializations
-#if TEST_STD_VER > 20
 static_assert(
     std::is_same_v< typename std::move_iterator<forward_iterator<char*>>::iterator_concept, std::forward_iterator_tag>);
 static_assert(std::is_same_v<typename std::move_iterator< bidirectional_iterator<char*>>::iterator_concept,
                              std::bidirectional_iterator_tag>);
 static_assert(std::is_same_v<typename std::move_iterator< random_access_iterator<char*>>::iterator_concept,
                              std::random_access_iterator_tag>);
 static_assert(std::is_same_v<typename std::move_iterator< contiguous_iterator<char*>>::iterator_concept,
                              std::random_access_iterator_tag>);
 static_assert(std::is_same_v<typename std::move_iterator<char*>::iterator_concept, std::random_access_iterator_tag>);
 
-#endif
 int main() {} // COMPILE-ONLY

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

 // move_iterator
 
 // Test nested types:
 
 // template <InputIterator Iter>
 // class move_iterator {
 // public:
 //  using iterator_type     = Iterator;
 //  using iterator_concept  = input_iterator_tag; // From C++20
 //  using iterator_category = see below; // not always present starting from C++20
 //  using value_type        = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type
 //  using difference_type   = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type;
 //  using pointer           = Iterator;
 //  using reference         = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&&
 // };
 
 #include <functional>
#if TEST_STD_VER > 17
   } else {
     static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
   }
 #else
   static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 #endif
 
 #if TEST_STD_VER < 20
   static_assert(std::is_same_v<typename R::iterator_concept, std::input_iterator_tag>);
 #endif
 }
 
 int main(int, char**) {
   test<cpp17_input_iterator<char*> >();
   test<forward_iterator<char*> >();
   test<bidirectional_iterator<char*> >();
   test<random_access_iterator<char*> >();
#if TEST_STD_VER >= 11
   }
   {
     typedef DummyIt<int, int&&> T;
     typedef std::move_iterator<T> It;
     static_assert(std::is_same<It::reference, int&&>::value, "");
   }
 #endif
 
-#if TEST_STD_VER > 17 && TEST_STD_VER <= 20 
+#if TEST_STD_VER < 20
   test<contiguous_iterator<char*>>();
   static_assert(
       std::is_same_v<typename std::move_iterator<forward_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
   static_assert(std::is_same_v<typename std::move_iterator<bidirectional_iterator<char*>>::iterator_concept,
                                std::input_iterator_tag>);
   static_assert(std::is_same_v<typename std::move_iterator<random_access_iterator<char*>>::iterator_concept,
                                std::input_iterator_tag>);
   static_assert(std::is_same_v<typename std::move_iterator<contiguous_iterator<char*>>::iterator_concept,
                                std::input_iterator_tag>);
   static_assert(std::is_same_v<typename std::move_iterator<char*>::iterator_concept, std::input_iterator_tag>);
 #endif
 
   return 0;
 }