[libc++] Implement P2520R0: `move_iterator<T*>` should be a random access iterator

[fsb4000]

Summary

I'm not 100% sure should it be DR or not.
MS STL implemented this as DR, https://github.com/microsoft/STL/pull/2958#discussion_r931710527
Let me know If you think we should implement it only for C++23

[philnik]

Someone else is already working on this: D135248

[fsb4000]

In D142841#4088845, @philnik wrote:

Someone else is already working on this: D135248

Thanks, I missed it :(

I searched only by this keyword: P2520R0...

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``
     ------------------------------------------------- -----------------

libcxx/docs/ReleaseNotes.rst

 the current one. To see the release notes for a specific release, please
 see the `releases page <https://llvm.org/releases/>`_.
 
 What's New in Libc++ 17.0.0?
 ============================
 
 Implemented Papers
 ------------------
+- P2520R0 - ``move_iterator<T*>`` should be a random access iterator
 
 Improvements and New Features
 -----------------------------
 
 Deprecations and Removals
 -------------------------
 
 Upcoming Deprecations and Removals

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2467R1 <https://wg21.link/P2467R1>`__","LWG","Support exclusive mode for ``fstreams``","July 2022","",""
 "`P2474R2 <https://wg21.link/P2474R2>`__","LWG","``views::repeat``","July 2022","","","|ranges|"
 "`P2494R2 <https://wg21.link/P2494R2>`__","LWG","Relaxing range adaptors to allow for move only types","July 2022","","","|ranges|"
 "`P2499R0 <https://wg21.link/P2499R0>`__","LWG","``string_view`` range constructor should be ``explicit``","July 2022","|Complete|","16.0","|ranges|"
 "`P2502R2 <https://wg21.link/P2502R2>`__","LWG","``std::generator``: Synchronous Coroutine Generator for Ranges","July 2022","","","|ranges|"
 "`P2508R1 <https://wg21.link/P2508R1>`__","LWG","Exposing ``std::basic-format-string``","July 2022","|Complete|","15.0"
 "`P2513R4 <https://wg21.link/P2513R4>`__","LWG","``char8_t`` Compatibility and Portability Fixes","July 2022","",""
 "`P2517R1 <https://wg21.link/P2517R1>`__","LWG","Add a conditional ``noexcept`` specification to ``std::apply``","July 2022","",""
-"`P2520R0 <https://wg21.link/P2520R0>`__","LWG","``move_iterator`` should be a random access iterator","July 2022","","","|ranges|"
+"`P2520R0 <https://wg21.link/P2520R0>`__","LWG","``move_iterator`` should be a random access iterator","July 2022","|Complete|","17.0","|ranges|"
 "`P2540R1 <https://wg21.link/P2540R1>`__","LWG","Empty Product for certain Views","July 2022","","","|ranges|"
 "`P2549R1 <https://wg21.link/P2549R1>`__","LWG","``std::unexpected`` should have ``error()`` as member accessor","July 2022","|Complete|","16.0"
 "`P2553R1 <https://wg21.link/P2553R1>`__","LWG","Make ``mdspan`` ``size_type`` controllable","July 2022","",""
 "`P2554R0 <https://wg21.link/P2554R0>`__","LWG","C-Array Interoperability of MDSpan","July 2022","",""
 "`P2585R0 <https://wg21.link/P2585R0>`__","LWG","Improving default container formatting","July 2022","|Partial|",""
 "`P2590R2 <https://wg21.link/P2590R2>`__","LWG","Explicit lifetime management","July 2022","",""
 "`P2599R2 <https://wg21.link/P2599R2>`__","LWG","``mdspan::size_type`` should be ``index_type``","July 2022","",""
 "`P2604R0 <https://wg21.link/P2604R0>`__","LWG","mdspan: rename pointer and contiguous","July 2022","",""

libcxx/include/__iterator/move_iterator.h

 #endif // _LIBCPP_STD_VER > 17
 
 template <class _Iter>
 class _LIBCPP_TEMPLATE_VIS move_iterator
 #if _LIBCPP_STD_VER > 17
     : public __move_iter_category_base<_Iter>
 #endif
 {
+#if _LIBCPP_STD_VER > 17
+private:
+    _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 > 17
 public:
 #if _LIBCPP_STD_VER > 17
     using iterator_type = _Iter;
-    using iterator_concept = input_iterator_tag;
+    using iterator_concept = decltype(__get_iter_concept());
     // 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<

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

 __cpp_lib_logical_traits                                201510L <type_traits>
 __cpp_lib_make_from_tuple                               201606L <tuple>
 __cpp_lib_make_reverse_iterator                         201402L <iterator>
 __cpp_lib_make_unique                                   201304L <memory>
 __cpp_lib_map_try_emplace                               201411L <map>
 __cpp_lib_math_constants                                201907L <numbers>
 __cpp_lib_math_special_functions                        201603L <cmath>
 __cpp_lib_memory_resource                               201603L <memory_resource>
+__cpp_lib_move_iterator_concept                         202207L <iterator>
 __cpp_lib_move_only_function                            202110L <functional>
 __cpp_lib_node_extract                                  201606L <map> <set> <unordered_map>
                                                                 <unordered_set>
 __cpp_lib_nonmember_container_access                    201411L <array> <deque> <forward_list>
                                                                 <iterator> <list> <map>
                                                                 <regex> <set> <string>
                                                                 <unordered_map> <unordered_set> <vector>
 __cpp_lib_not_fn                                        201603L <functional>

 # 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

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

void test()
     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::forward_iterator<iterator>);
+    static_assert(!std::bidirectional_iterator<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_copyable<int*, iterator>);
     static_assert(!std::indirectly_copyable_storable<int*, 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::bidirectional_iterator<iterator>);
+    static_assert(!std::random_access_iterator<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_copyable<int*, iterator>);
     static_assert(!std::indirectly_copyable_storable<int*, 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::random_access_iterator<iterator>);
+    static_assert(!std::contiguous_iterator<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_copyable<int*, iterator>);
     static_assert(!std::indirectly_copyable_storable<int*, 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::random_access_iterator<iterator>);
+    static_assert(!std::contiguous_iterator<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_copyable<int*, iterator>);
     static_assert(!std::indirectly_copyable_storable<int*, 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::random_access_iterator<iterator>);
+    static_assert(!std::contiguous_iterator<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_copyable<int*, iterator>);
     static_assert(!std::indirectly_copyable_storable<int*, iterator>);
     static_assert( std::indirectly_readable<iterator>);
     static_assert(!std::indirectly_writable<iterator, int>);
     static_assert( std::indirectly_swappable<iterator, iterator>);
   }
 }

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_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&&
 // };
 
 #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 > 17
-  static_assert(std::is_same_v<typename R::iterator_concept, std::input_iterator_tag>);
+  static_assert(std::is_same_v<typename R::iterator_concept, typename R::iterator_category>);
 #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<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>);
+  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
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.compile.pass.cpp

 
 // Test the feature test macros defined by <iterator>
 
 /*  Constant                                Value
     __cpp_lib_array_constexpr               201603L [C++17]
                                             201811L [C++20]
     __cpp_lib_constexpr_iterator            201811L [C++20]
     __cpp_lib_make_reverse_iterator         201402L [C++14]
+    __cpp_lib_move_iterator_concept         202207L [C++20]
     __cpp_lib_nonmember_container_access    201411L [C++17]
     __cpp_lib_null_iterators                201304L [C++14]
     __cpp_lib_ranges                        202106L [C++20]
     __cpp_lib_ssize                         201902L [C++20]
 */
 
 #include <iterator>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_iterator
 #   error "__cpp_lib_constexpr_iterator should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should not be defined before c++14"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should not be defined before c++20"
+# endif
+
 # ifdef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_null_iterators
 #   error "__cpp_lib_null_iterators should not be defined before c++14"
 # endif
 

 
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++14"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++14"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should not be defined before c++20"
+# endif
+
 # ifdef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
 # endif
 
 # ifndef __cpp_lib_null_iterators
 #   error "__cpp_lib_null_iterators should be defined in c++14"
 # endif
 # if __cpp_lib_null_iterators != 201304L

 
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++17"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++17"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should not be defined before c++20"
+# endif
+
 # ifndef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should be defined in c++17"
 # endif
 # if __cpp_lib_nonmember_container_access != 201411L
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
 # endif
 
 # ifndef __cpp_lib_null_iterators

 
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++20"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++20"
 # endif
 
+# ifndef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should be defined in c++20"
+# endif
+# if __cpp_lib_move_iterator_concept != 202207L
+#   error "__cpp_lib_move_iterator_concept should have the value 202207L in c++20"
+# endif
+
 # ifndef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should be defined in c++20"
 # endif
 # if __cpp_lib_nonmember_container_access != 201411L
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++20"
 # endif
 
 # ifndef __cpp_lib_null_iterators

 
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++2b"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++2b"
 # endif
 
+# ifndef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should be defined in c++2b"
+# endif
+# if __cpp_lib_move_iterator_concept != 202207L
+#   error "__cpp_lib_move_iterator_concept should have the value 202207L in c++2b"
+# endif
+
 # ifndef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should be defined in c++2b"
 # endif
 # if __cpp_lib_nonmember_container_access != 201411L
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2b"
 # endif
 
 # ifndef __cpp_lib_null_iterators

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

/*  Constant                                       Value
     __cpp_lib_logical_traits                       201510L [C++17]
     __cpp_lib_make_from_tuple                      201606L [C++17]
     __cpp_lib_make_reverse_iterator                201402L [C++14]
     __cpp_lib_make_unique                          201304L [C++14]
     __cpp_lib_map_try_emplace                      201411L [C++17]
     __cpp_lib_math_constants                       201907L [C++20]
     __cpp_lib_math_special_functions               201603L [C++17]
     __cpp_lib_memory_resource                      201603L [C++17]
+    __cpp_lib_move_iterator_concept                202207L [C++20]
     __cpp_lib_move_only_function                   202110L [C++2b]
     __cpp_lib_node_extract                         201606L [C++17]
     __cpp_lib_nonmember_container_access           201411L [C++17]
     __cpp_lib_not_fn                               201603L [C++17]
     __cpp_lib_null_iterators                       201304L [C++14]
     __cpp_lib_optional                             201606L [C++17]
                                                    202110L [C++2b]
     __cpp_lib_out_ptr                              202106L [C++2b]

 # ifdef __cpp_lib_math_special_functions
 #   error "__cpp_lib_math_special_functions should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should not be defined before c++20"
+# endif
+
 # ifdef __cpp_lib_move_only_function
 #   error "__cpp_lib_move_only_function should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_node_extract
 #   error "__cpp_lib_node_extract should not be defined before c++17"
 # endif
 

 # ifdef __cpp_lib_math_special_functions
 #   error "__cpp_lib_math_special_functions should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should not be defined before c++20"
+# endif
+
 # ifdef __cpp_lib_move_only_function
 #   error "__cpp_lib_move_only_function should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_node_extract
 #   error "__cpp_lib_node_extract should not be defined before c++17"
 # endif
 

 
 # ifndef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should be defined in c++17"
 # endif
 # if __cpp_lib_memory_resource != 201603L
 #   error "__cpp_lib_memory_resource should have the value 201603L in c++17"
 # endif
 
+# ifdef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should not be defined before c++20"
+# endif
+
 # ifdef __cpp_lib_move_only_function
 #   error "__cpp_lib_move_only_function should not be defined before c++2b"
 # endif
 
 # ifndef __cpp_lib_node_extract
 #   error "__cpp_lib_node_extract should be defined in c++17"
 # endif
 # if __cpp_lib_node_extract != 201606L

 
 # ifndef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should be defined in c++20"
 # endif
 # if __cpp_lib_memory_resource != 201603L
 #   error "__cpp_lib_memory_resource should have the value 201603L in c++20"
 # endif
 
+# ifndef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should be defined in c++20"
+# endif
+# if __cpp_lib_move_iterator_concept != 202207L
+#   error "__cpp_lib_move_iterator_concept should have the value 202207L in c++20"
+# endif
+
 # ifdef __cpp_lib_move_only_function
 #   error "__cpp_lib_move_only_function should not be defined before c++2b"
 # endif
 
 # ifndef __cpp_lib_node_extract
 #   error "__cpp_lib_node_extract should be defined in c++20"
 # endif
 # if __cpp_lib_node_extract != 201606L

 
 # ifndef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should be defined in c++2b"
 # endif
 # if __cpp_lib_memory_resource != 201603L
 #   error "__cpp_lib_memory_resource should have the value 201603L in c++2b"
 # endif
 
+# ifndef __cpp_lib_move_iterator_concept
+#   error "__cpp_lib_move_iterator_concept should be defined in c++2b"
+# endif
+# if __cpp_lib_move_iterator_concept != 202207L
+#   error "__cpp_lib_move_iterator_concept should have the value 202207L in c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_move_only_function
 #     error "__cpp_lib_move_only_function should be defined in c++2b"
 #   endif
 #   if __cpp_lib_move_only_function != 202110L
 #     error "__cpp_lib_move_only_function should have the value 202110L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "values": { "c++17": 201603 },
     "headers": ["cmath"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_memory_resource",
     "values": { "c++17": 201603 },
     "headers": ["memory_resource"],
   }, {
+    "name": "__cpp_lib_move_iterator_concept",
+    "values": { "c++20": 202207 },
+    "headers": ["iterator"],
+  }, {
     "name": "__cpp_lib_move_only_function",
     "values": { "c++2b": 202110 },
     "headers": ["functional"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_node_extract",
     "values": { "c++17": 201606 },
     "headers": ["map", "set", "unordered_map", "unordered_set"],