[libc++][ranges] Finish LWG issues directly related to the One Ranges Proposal.

[var-const]

Summary

• P1252 ("Ranges Design Cleanup") -- deprecate move_iterator::operator-> starting from C++20; add range comparisons to the <functional> synopsis. This restores move_iterator::operator-> that was incorrectly deleted in D117656; it's still defined in the latest draft, see http://eel.is/c++draft/depr.move.iter.elem. Note that changes to *_result types from 6.1 in the paper are no longer relevant now that these types are aliases;
• P2106 ("Alternative wording for GB315 and GB316") -- add a few *_result types to the synopsis in <algorithm> (some algorithms are not implemented yet and thus some of the proposal still cannot be marked as done);

Also mark already done issues as done (or as nothing to do):

• P2091 ("Fixing Issues With Range Access CPOs") was already implemented (this patch adds tests for some ill-formed cases);
• LWG 3247 ("ranges::iter_move should perform ADL-only lookup of iter_move") was already implemented;
• LWG 3300 ("Non-array ssize overload is underconstrained") doesn't affect the implementation;
• LWG 3335 ("Resolve C++20 NB comments US 273 and GB 274") was already implemented;
• LWG 3355 ("The memory algorithms should support move-only input iterators introduced by P1207") was already implemented (except for testing).

[philnik]

LGTM % nit

libcxx/include/algorithm

669–682

Maybe just move this to the other algorithms?

[ldionne]

LGTM with comments applied and CI passing.

libcxx/include/__iterator/move_iterator.h

161

Can we add a test for this deprecation? Example in libcxx/test/std/utilities/memory/storage.iterator/deprecated.verify.cpp.

libcxx/include/__ranges/empty.h

31 ↗

(On Diff #430920)

Do you mind checking-in these formatting changes separately? No need for a review, mark it as NFC.

Doing it as a separate commit makes it less confusing when looking at git blame output, git log and it's also possible to ignore it in .git-blame-ignore-revs (or whatever it's called).

libcxx/include/iterator

409

I would instead say

constexpr pointer operator->() const; // deprecated in C++20

And if they remove it at some point, I would say // deprecated in C++20, removed in C++XY.

libcxx/test/std/ranges/range.access/begin.verify.cpp

13

I think these tests are fine, however it would be nice to add a small comment explaining that we're ensuring that our implementation produces a diagnostic for this ill-formed case.

[var-const]

libcxx/include/__iterator/move_iterator.h

161

Done. This uncovered a significant issue -- D117656 incorrectly removed this operator completely in C++20, rather than merely deprecating it. move_iterator::operator-> is still defined (as deprecated) even in the latest draft, in http://eel.is/c++draft/depr.move.iter.elem.

libcxx/include/algorithm

669–682

I'd rather keep as is and do a dedicated cleanup patch for the algorithm synopsis to make sure we follow the ordering from the standard.

[var-const]

Address feedback

[var-const]

Fix the CI.

libcxx/docs/Status/Cxx20Issues.csv

 "`3200 <https://wg21.link/LWG3200>`__","``midpoint``\  should not constrain ``T``\  is complete","Prague","|Nothing To Do|",""
 "`3201 <https://wg21.link/LWG3201>`__","``lerp``\  should be marked as ``noexcept``\ ","Prague","|Complete|",""
 "`3226 <https://wg21.link/LWG3226>`__","``zoned_time``\  constructor from ``string_view``\  should accept ``zoned_time<Duration2, TimeZonePtr2>``\ ","Prague","","","|chrono|"
 "`3233 <https://wg21.link/LWG3233>`__","Broken requirements for ``shared_ptr``\  converting constructors","Prague","",""
 "`3237 <https://wg21.link/LWG3237>`__","LWG 3038 and 3190 have inconsistent PRs","Prague","|Complete|","14.0"
 "`3238 <https://wg21.link/LWG3238>`__","Insufficiently-defined behavior of ``std::function``\  deduction guides","Prague","",""
 "`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\  in ``width``\  and ``precision``\ ","Prague","|Complete|","Clang 14","|format|"
 "`3243 <https://wg21.link/LWG3243>`__","``std::format``\  and negative zeroes","Prague","|Complete|","14.0","|format|"
-"`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\  should perform ADL-only lookup of ``iter_move``\ ","Prague","","","|ranges|"
+"`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\  should perform ADL-only lookup of ``iter_move``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3248 <https://wg21.link/LWG3248>`__","``std::format``\  ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\   presentation types misformat negative numbers","Prague","|Complete|","14.0","|format|"
 "`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\  (alternate form) for NaN and inf","Prague","|Complete|","14.0","|format|"
 "`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\  alignment specifiers applied to string arguments?","Prague","|Complete|","14.0","|format|"
 "`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague","","","|chrono|"
 "`3254 <https://wg21.link/LWG3254>`__","Strike ``stop_token``\ 's ``operator!=``\ ","Prague","",""
 "`3255 <https://wg21.link/LWG3255>`__","``span``\ 's ``array``\  constructor is too strict","Prague","|Complete|",""
 "`3260 <https://wg21.link/LWG3260>`__","``year_month*``\  arithmetic rejects durations convertible to years","Prague","","","|chrono|"
 "`3262 <https://wg21.link/LWG3262>`__","Formatting of negative durations is not specified","Prague","","","|chrono| |format|"
 "`3264 <https://wg21.link/LWG3264>`__","``sized_range``\  and ``ranges::size``\  redundantly use ``disable_sized_range``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3269 <https://wg21.link/LWG3269>`__","Parse manipulators do not specify the result of the extraction from stream","Prague","","","|chrono|"
 "`3270 <https://wg21.link/LWG3270>`__","Parsing and formatting ``%j``\  with ``duration``\ s","Prague","","","|chrono| |format|"
 "`3280 <https://wg21.link/LWG3280>`__","View converting constructors can cause constraint recursion and are unneeded","Prague","|Complete|","15.0","|ranges|"
 "`3281 <https://wg21.link/LWG3281>`__","Conversion from ``*pair-like*``\  types to ``subrange``\  is a silent semantic promotion","Prague","|Complete|","15.0","|ranges|"
 "`3282 <https://wg21.link/LWG3282>`__","``subrange``\  converting constructor should disallow derived to base conversions","Prague","|Complete|","15.0","|ranges|"
 "`3284 <https://wg21.link/LWG3284>`__","``random_access_iterator``\  semantic constraints accidentally promote difference type  using unary negate","Prague","|Nothing To Do|","","|ranges|"
 "`3285 <https://wg21.link/LWG3285>`__","The type of a customization point object shall satisfy ``semiregular``\ ","Prague","|Nothing To Do|","","|ranges|"
 "`3286 <https://wg21.link/LWG3286>`__","``ranges::size``\  is not required to be valid after a call to ``ranges::begin``\  on an input range","Prague","|Complete|","15.0","|ranges|"
 "`3291 <https://wg21.link/LWG3291>`__","``iota_view::iterator``\  has the wrong ``iterator_category``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3292 <https://wg21.link/LWG3292>`__","``iota_view``\  is under-constrained","Prague","|Complete|","15.0","|ranges|"
 "`3294 <https://wg21.link/LWG3294>`__","``zoned_time``\  deduction guides misinterprets ``string``\ /``char*``\ ","Prague","","","|chrono|"
 "`3296 <https://wg21.link/LWG3296>`__","Inconsistent default argument for ``basic_regex<>::assign``\ ","Prague","|Complete|",""
 "`3299 <https://wg21.link/LWG3299>`__","Pointers don't need customized iterator behavior","Prague","|Complete|","15.0","|ranges|"
-"`3300 <https://wg21.link/LWG3300>`__","Non-array ``ssize``\  overload is underconstrained","Prague","",""
+"`3300 <https://wg21.link/LWG3300>`__","Non-array ``ssize``\  overload is underconstrained","Prague","|Nothing To Do|",""
 "`3301 <https://wg21.link/LWG3301>`__","``transform_view::iterator``\  has incorrect ``iterator_category``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3302 <https://wg21.link/LWG3302>`__","Range adaptor objects ``keys``\  and ``values``\  are unspecified","Prague","","","|ranges|"
 "`3303 <https://wg21.link/LWG3303>`__","Bad ""``constexpr``\ "" marker for ``destroy/destroy_n``\ ","Prague","",""
 "`3304 <https://wg21.link/LWG3304>`__","Allocate functions of ``std::polymorphic_allocator``\  should require ``[[nodiscard]]``\ ","Prague","",""
 "`3307 <https://wg21.link/LWG3307>`__","``std::allocator<void>().allocate(n)``\ ","Prague","",""
 "`3310 <https://wg21.link/LWG3310>`__","Replace ``SIZE_MAX``\  with ``numeric_limits<size_t>::max()``\ ","Prague","",""
 "`3313 <https://wg21.link/LWG3313>`__","``join_view::iterator::operator--``\  is incorrectly constrained","Prague","|Complete|","14.0","|ranges|"
 "`3314 <https://wg21.link/LWG3314>`__","Is stream insertion behavior locale dependent when ``Period::type``\  is ``micro``\ ?","Prague","","","|chrono|"

 "`3326 <https://wg21.link/LWG3326>`__","``enable_view``\  has false positives","Prague","|Complete|","15.0","|ranges|"
 "`3327 <https://wg21.link/LWG3327>`__","Format alignment specifiers vs. text direction","Prague","|Nothing To Do|","","|format|"
 "`3328 <https://wg21.link/LWG3328>`__","Clarify that ``std::string``\  is not good for UTF-8","Prague","",""
 "`3329 <https://wg21.link/LWG3329>`__","``totally_ordered_with``\  both directly and indirectly requires ``common_reference_with``\ ","Prague","|Complete|","13.0"
 "`3330 <https://wg21.link/LWG3330>`__","Include ``<compare>``\  from most library headers","Prague","|Complete|","13.0","|spaceship|"
 "`3331 <https://wg21.link/LWG3331>`__","Define ``totally_ordered/_with``\  in terms of ``partially-ordered-with``\ ","Prague","|Complete|","13.0"
 "`3332 <https://wg21.link/LWG3332>`__","Issue in |sect|\ [time.format]","Prague","","","|chrono| |format|"
 "`3334 <https://wg21.link/LWG3334>`__","``basic_osyncstream``\  move assignment and destruction calls ``basic_syncbuf::emit()``\  twice","Prague","",""
-"`3335 <https://wg21.link/LWG3335>`__","Resolve C++20 NB comments US 273 and GB 274","Prague","","","|ranges|"
+"`3335 <https://wg21.link/LWG3335>`__","Resolve C++20 NB comments US 273 and GB 274","Prague","|Complete|","15.0","|ranges|"
 "`3338 <https://wg21.link/LWG3338>`__","Rename ``default_constructible``\  to ``default_initializable``\ ","Prague","|Complete|","13.0"
 "`3340 <https://wg21.link/LWG3340>`__","Formatting functions should throw on argument/format string mismatch in |sect|\ [format.functions]","Prague","|Complete|","14.0","|format|"
 "`3346 <https://wg21.link/LWG3346>`__","``pair``\  and ``tuple``\  copy and move constructor have backwards specification","Prague","",""
 "`3347 <https://wg21.link/LWG3347>`__","``std::pair<T, U>``\  now requires ``T``\  and ``U``\  to be less-than-comparable","Prague","",""
 "`3348 <https://wg21.link/LWG3348>`__","``__cpp_lib_unwrap_ref``\  in wrong header","Prague","|Complete|","12.0"
 "`3349 <https://wg21.link/LWG3349>`__","Missing ``__cpp_lib_constexpr_complex``\  for P0415R1","Prague","",""
 "`3350 <https://wg21.link/LWG3350>`__","Simplify return type of ``lexicographical_compare_three_way``\ ","Prague","","","|spaceship|"
 "`3351 <https://wg21.link/LWG3351>`__","``ranges::enable_safe_range``\  should not be constrained","Prague","|Complete|","15.0","|ranges|"
 "`3352 <https://wg21.link/LWG3352>`__","``strong_equality``\  isn't a thing","Prague","|Nothing To Do|","","|spaceship|"
 "`3354 <https://wg21.link/LWG3354>`__","``has_strong_structural_equality``\  has a meaningless definition","Prague","|Nothing To Do|","","|spaceship|"
-"`3355 <https://wg21.link/LWG3355>`__","The memory algorithms should support move-only input iterators introduced by P1207","Prague","","","|ranges|"
+"`3355 <https://wg21.link/LWG3355>`__","The memory algorithms should support move-only input iterators introduced by P1207","Prague","|Complete|","15.0","|ranges|"
 "`3356 <https://wg21.link/LWG3356>`__","``__cpp_lib_nothrow_convertible``\  should be ``__cpp_lib_is_nothrow_convertible``\ ","Prague","|Complete|","12.0"
 "`3358 <https://wg21.link/LWG3358>`__","|sect|\ [span.cons] is mistaken that ``to_address``\  can throw","Prague","",""
 "`3359 <https://wg21.link/LWG3359>`__","``<chrono>``\  leap second support should allow for negative leap seconds","Prague","","","|chrono|"
 "`3360 <https://wg21.link/LWG3360>`__","``three_way_comparable_with``\  is inconsistent with similar concepts","Prague","|Nothing To Do|","","|spaceship|"
 "`3362 <https://wg21.link/LWG3362>`__","Strike ``stop_source``\ 's ``operator!=``\ ","Prague","",""
 "`3363 <https://wg21.link/LWG3363>`__","``drop_while_view``\  should opt-out of ``sized_range``\ ","Prague","|Nothing To Do|","","|ranges|"
 "`3364 <https://wg21.link/LWG3364>`__","Initialize data members of ranges and their iterators","Prague","","","|ranges|"
 "`3367 <https://wg21.link/LWG3367>`__","Integer-class conversions should not throw","Prague","|Nothing To Do|",""

libcxx/docs/Status/Cxx20Papers.csv

 "`P1976R2 <https://wg21.link/P1976R2>`__","LWG","Fixed-size span construction from dynamic range","Prague","|Complete|","11.0"
 "`P1981R0 <https://wg21.link/P1981R0>`__","LWG","Rename leap to leap_second","Prague","* *",""
 "`P1982R0 <https://wg21.link/P1982R0>`__","LWG","Rename link to time_zone_link","Prague","* *",""
 "`P1983R0 <https://wg21.link/P1983R0>`__","LWG","Wording for GB301, US296, US292, US291, and US283","Prague","|Complete|","15.0"
 "`P1994R1 <https://wg21.link/P1994R1>`__","LWG","elements_view needs its own sentinel","Prague","* *",""
 "`P2002R1 <https://wg21.link/P2002R1>`__","CWG","Defaulted comparison specification cleanups","Prague","* *",""
 "`P2045R1 <https://wg21.link/P2045R1>`__","LWG","Missing Mandates for the standard library","Prague","* *",""
 "`P2085R0 <https://wg21.link/P2085R0>`__","CWG","Consistent defaulted comparisons","Prague","* *",""
-"`P2091R0 <https://wg21.link/P2091R0>`__","LWG","Issues with range access CPOs","Prague","* *",""
+"`P2091R0 <https://wg21.link/P2091R0>`__","LWG","Issues with range access CPOs","Prague","|Complete|","15.0"
 "`P2101R0 <https://wg21.link/P2101R0>`__","LWG","'Models' subsumes 'satisfies' (Wording for US298 and US300)","Prague","* *",""
 "`P2102R0 <https://wg21.link/P2102R0>`__","LWG","Make 'implicit expression variations' more explicit (Wording for US185)","Prague","* *",""
 "`P2106R0 <https://wg21.link/P2106R0>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
 "`P2116R0 <https://wg21.link/P2116R0>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
 "","","","","",""
 "`P2231R1 <https://wg21.link/P2231R1>`__","LWG","Missing constexpr in std::optional and std::variant","June 2021","|Partial| [#note-P2231]_","13.0"
 "`P2325R3 <https://wg21.link/P2325R3>`__","LWG","Views should not be required to be default constructible","June 2021","|In progress|",""
 "`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","",""

libcxx/docs/Status/RangesIssues.csv

 `P1739R4 <https://wg21.link/P1739R4>`__,Avoiding Template Bloat For Ranges,|Complete|,15.0
 `P1862R1 <https://wg21.link/P1862R1>`__,Range Adaptors For Non-Copyable Iterators,,
 `P1870R1 <https://wg21.link/P1870R1>`__,forwarding-range<T> is too subtle,|Complete|,15.0
 `P1871R1 <https://wg21.link/P1871R1>`__,disable_sized_sentinel_for,|Complete|,14.0
 `P1878R1 <https://wg21.link/P1878R1>`__,Constraining Readable Types,|Complete|,15.0
 `P1970R2 <https://wg21.link/P1970R2>`__,Consistency for size() functions: Add ranges::ssize,|Complete|,15.0
 `P1983R0 <https://wg21.link/P1983R0>`__,"Wording for GB301, US296, US292, US291, and US283",|Complete|,15.0
 `P1994R1 <https://wg21.link/P1994R1>`__,elements_view Needs Its Own sentinel,,
-`P2091R0 <https://wg21.link/P2091R0>`__,Fixing Issues With Range Access CPOs,,
+`P2091R0 <https://wg21.link/P2091R0>`__,Fixing Issues With Range Access CPOs,|Complete|,15.0
 `P2106R0 <https://wg21.link/P2106R0>`__,Range Algorithm Result Types,,
 
 `P2325R3 <https://wg21.link/P2325R3>`__,Views should not be required to be default constructible ,,
 `P2328R1 <https://wg21.link/P2328R1>`__,join_view should join all views of ranges,|Complete|,14.0
 `P2210R2 <https://wg21.link/P2210R2>`__,Superior String Splitting,,
 `P2281R1 <https://wg21.link/P2281R1>`__,Clarifying range adaptor objects,|Complete|,14.0
 `P2367R0 <https://wg21.link/P2367R0>`__,Remove misuses of list-initialization from Clause 24,,
 
 `P2415 <https://wg21.link/P2415>`__,"What is a ``view``",|Complete|,14.0
 `P2432 <https://wg21.link/P2432>`__,"Fix ``istream_view``",,

libcxx/include/__iterator/move_iterator.h

 #endif // _LIBCPP_STD_VER > 17
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator++() { ++__current_; return *this; }
 
+    _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
+    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()) {}
move_iterator& operator=(const move_iterator<_Up>& __u) {
         return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     _Iter base() const { return __current_; }
 
     _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_; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; }
 #endif // _LIBCPP_STD_VER > 17
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator--() { --__current_; return *this; }

libcxx/include/__ranges/size.h

namespace ranges {
   template<class>
   inline constexpr bool disable_sized_range = false;
 } // namespace ranges
 
 // [range.prim.size]
 
 namespace ranges {
 namespace __size {
-  void size(auto&) = delete;
-  void size(const auto&) = delete;
 
-  template <class _Tp>
-  concept __size_enabled = !disable_sized_range<remove_cvref_t<_Tp>>;
 
-  template <class _Tp>
-  concept __member_size =
-    __size_enabled<_Tp> &&
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
-    };
 
-  template <class _Tp>
-  concept __unqualified_size =
-    __size_enabled<_Tp> &&
-    !__member_size<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
-    };
 
-  template <class _Tp>
-  concept __difference =
-    !__member_size<_Tp> &&
-    !__unqualified_size<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp&& __t) {
-      { ranges::begin(__t) } -> forward_iterator;
-      { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(declval<_Tp>()))>;
-    };
 
-  struct __fn {
-    template <class _Tp, size_t _Sz>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
-      return _Sz;
-    }
+
+  // `[range.prim.size]`: the array case (for rvalues).
 
-    template <class _Tp, size_t _Sz>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&)[_Sz]) const noexcept {
-      return _Sz;
-    }
+  // `[range.prim.size]`: the array case (for lvalues).
 
-    template <__member_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.size()))) {
-      return _LIBCPP_AUTO_CAST(__t.size());
-    }
+  // `[range.prim.size]`: `auto(t.size())` is a valid expression.
 
-    template <__unqualified_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_LIBCPP_AUTO_CAST(size(__t)))) {
-      return _LIBCPP_AUTO_CAST(size(__t));
-    }
+  // `[range.prim.size]`: `auto(size(t))` is a valid expression.
 
-    template<__difference _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
-      return std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
-    }
-  };
+  // [range.prim.size]: the `to-unsigned-like` case.
+  template <__difference _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+    noexcept(noexcept(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))))
+    -> decltype(      std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t)))
+    { return          std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
+
 } // namespace __size
 
 inline namespace __cpo {
   inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.prim.ssize]
 
 namespace ranges {
 namespace __ssize {
-  struct __fn {
-    template<class _Tp>
-      requires requires (_Tp&& __t) { ranges::size(__t); }
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::size(__t)))
-    {
-      using _Signed = make_signed_t<decltype(ranges::size(__t))>;
-      if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
-        return static_cast<ptrdiff_t>(ranges::size(__t));
-      else
-        return static_cast<_Signed>(ranges::size(__t));
-    }
-  };
+    noexcept(noexcept(ranges::size(__t))) {
 } // namespace __ssize
 
 inline namespace __cpo {
   inline constexpr auto ssize = __ssize::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_SIZE_H

libcxx/include/algorithm

/*
     algorithm synopsis
 
 #include <initializer_list>
 
 namespace std
 {
 
 namespace ranges {
+
+  // [algorithms.results], algorithm result types
   template <class I, class F>
     struct in_fun_result;     // since C++20
 
   template <class I1, class I2>
     struct in_in_result;      // since C++20
 
+  template <class I, class O>
+    struct in_out_result;  // since C++20
+
   template <class I1, class I2, class O>
     struct in_in_out_result;  // since C++20
 
   template <class I, class O1, class O2>
     struct in_out_out_result; // since C++20
 
   template <class I1, class I2>
     struct min_max_result;    // since C++20
namespace ranges {
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
     indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});                        // since C++20
 
   template<forward_range R, class Proj = identity,
     indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});             // since C++20
 
+  template<class I1, class I2>
+    using mismatch_result = in_in_result<I1, I2>;
+
   template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
   constexpr mismatch_result<_I1, _I2>
   mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
 
   template <input_range R1, input_range R2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
     constexpr iter_difference_t<I>
       count_if(I first, S last, Pred pred, Proj proj = {});                         // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr range_difference_t<R>
       count_if(R&& r, Pred pred, Proj proj = {});                                   // since C++20
 
+  template<class T>
+  using minmax_result = min_max_result<T>;
+
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_result<const T&>
       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});                     // since C++20
 
   template<copyable T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_result<T>
       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});                      // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
     constexpr ranges::minmax_result<range_value_t<R>>
       minmax(R&& r, Comp comp = {}, Proj proj = {});                                      // since C++20
 
+  template<class I>
+  using minmax_element_result = min_max_result<I>;
+
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_element_result<I>
       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});                    // since C++20
 
   template<forward_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
       minmax_element(R&& r, Comp comp = {}, Proj proj = {});                              // since C++20
 
   template<class I, class O>
-      using copy_result = in_out_result<I, O>;                                              // since C++20
 
-    template<class I, class O>
-      using copy_n_result = in_out_result<I, O>;                                            // since C++20
 
   template<class I, class O>
     using copy_if_result = in_out_result<I, O>;                                             // since C++20
 
   template<class I1, class I2>
     using copy_backward_result = in_out_result<I1, I2>;                                     // since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
template<class InputIterator, class Size, class OutputIterator>
     constexpr OutputIterator      // constexpr in C++20
     copy_n(InputIterator first, Size n, OutputIterator result);
 
 template <class BidirectionalIterator1, class BidirectionalIterator2>
     constexpr BidirectionalIterator2      // constexpr in C++20
     copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
 
+// [alg.move], move
+template<class InputIterator, class OutputIterator>
+    constexpr OutputIterator move(InputIterator first, InputIterator last,
+                                OutputIterator result);
+
+template<class BidirectionalIterator1, class BidirectionalIterator2>
+    constexpr BidirectionalIterator2
+    move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
+                  BidirectionalIterator2 result);
+
 template <class ForwardIterator1, class ForwardIterator2>
     constexpr ForwardIterator2    // constexpr in C++20
     swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
 
+namespace ranges {
+    template<class I1, class I2>
+    using swap_ranges_result = in_in_result<I1, I2>;
+
 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
         requires indirectly_swappable<I1, I2>
     constexpr ranges::swap_ranges_result<I1, I2>
-        ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
+        swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
 
 template<input_range R1, input_range R2>
         requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
     constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
-        ranges::swap_ranges(R1&& r1, R2&& r2);
+        swap_ranges(R1&& r1, R2&& r2);
+}
 
 template <class ForwardIterator1, class ForwardIterator2>
     constexpr void                // constexpr in C++20
     iter_swap(ForwardIterator1 a, ForwardIterator2 b);
 
 template <class InputIterator, class OutputIterator, class UnaryOperation>
     constexpr OutputIterator      // constexpr in C++20
     transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);

libcxx/include/functional

 
 template <> struct hash<float>;
 template <> struct hash<double>;
 template <> struct hash<long double>;
 
 template<class T> struct hash<T*>;
 template <> struct hash<nullptr_t>;  // C++17
 
+namespace ranges {
+  // [range.cmp], concept-constrained comparisons
+  struct equal_to;
+  struct not_equal_to;
+  struct greater;
+  struct less;
+  struct greater_equal;
+  struct less_equal;
+}
+
 }  // std
 
 POLICY:  For non-variadic implementations, the number of arguments is limited
          to 3.  It is hoped that the need for non-variadic implementations
          will be minimal.
 
 */
 

libcxx/include/iterator

public:
     template <class U>
       constexpr move_iterator& operator=(const move_iterator<U>& u);
 
     constexpr iterator_type base() const; // Until C++20
     constexpr const Iterator& base() const & noexcept; // From C++20
     constexpr Iterator base() &&; // From C++20
 
     constexpr reference operator*() const;
-    constexpr pointer operator->() const; // Removed in C++20
+    constexpr pointer operator->() const; // Deprecated in C++20
     constexpr move_iterator& operator++();
     constexpr auto operator++(int); // Return type was move_iterator until C++20
     constexpr move_iterator& operator--();
     constexpr move_iterator operator--(int);
     constexpr move_iterator operator+(difference_type n) const;
     constexpr move_iterator& operator+=(difference_type n);
     constexpr move_iterator operator-(difference_type n) const;
     constexpr move_iterator& operator-=(difference_type n);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/deprecated.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// move_iterator
+
+#include <iterator>
+
+int main(int, char**) {
+  (void)std::move_iterator<int*>().operator->();
+  // expected-warning@-1{{'operator->' is deprecated}}
+
+  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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 // <iterator>
 
 // move_iterator
 
 // pointer operator->() const;
 //
 //  constexpr in C++17
-//  removed in C++20
+//  deprecated in C++20
 
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 
-#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()
 {
-#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**)
 {
     test();
 #if TEST_STD_VER > 14
     static_assert(test());
 #endif
 
     return 0;
 }

libcxx/test/std/ranges/range.access/begin.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::begin
+
+#include <ranges>
+
+struct NonBorrowedRange {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(!std::ranges::enable_borrowed_range<NonBorrowedRange>);
+
+// Verify that if the expression is an rvalue and `enable_borrowed_range` is false, `ranges::begin` is ill-formed.
+void test() {
+  std::ranges::begin(NonBorrowedRange());
+  // expected-error-re@-1 {{{{call to deleted function call operator in type 'const (std::ranges::)?__begin::__fn'}}}}
+  // expected-error@-2  {{attempt to use a deleted function}}
+}

libcxx/test/std/ranges/range.access/data.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::data
+
+#include <ranges>
+
+struct NonBorrowedRange {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(!std::ranges::enable_borrowed_range<NonBorrowedRange>);
+
+// Verify that if the expression is an rvalue and `enable_borrowed_range` is false, `ranges::data` is ill-formed.
+void test() {
+  std::ranges::data(NonBorrowedRange());
+  // expected-error-re@-1 {{{{no matching function for call to object of type 'const (std::ranges::)?__data::__fn'}}}}
+}

libcxx/test/std/ranges/range.access/empty.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::empty
+
+#include <ranges>
+
+extern int arr[];
+
+// Verify that for an array of unknown bound `ranges::empty` is ill-formed.
+void test() {
+  std::ranges::empty(arr);
+  // expected-error-re@-1 {{{{no matching function for call to object of type 'const (std::ranges::)?__empty::__fn'}}}}
+}

libcxx/test/std/ranges/range.access/end.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::end
+
+#include <ranges>
+
+struct NonBorrowedRange {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(!std::ranges::enable_borrowed_range<NonBorrowedRange>);
+
+// Verify that if the expression is an rvalue and `enable_borrowed_range` is false, `ranges::end` is ill-formed.
+void test() {
+  std::ranges::end(NonBorrowedRange());
+  // expected-error-re@-1 {{{{call to deleted function call operator in type 'const (std::ranges::)?__end::__fn'}}}}
+  // expected-error@-2  {{attempt to use a deleted function}}
+}

libcxx/test/std/ranges/range.access/rbegin.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::rbegin
+
+#include <ranges>
+
+struct NonBorrowedRange {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(!std::ranges::enable_borrowed_range<NonBorrowedRange>);
+
+// Verify that if the expression is an rvalue and `enable_borrowed_range` is false, `ranges::rbegin` is ill-formed.
+void test() {
+  std::ranges::rbegin(NonBorrowedRange());
+  // expected-error-re@-1 {{{{call to deleted function call operator in type 'const (std::ranges::)?__rbegin::__fn'}}}}
+  // expected-error@-2  {{attempt to use a deleted function}}
+}

libcxx/test/std/ranges/range.access/rend.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::rend
+
+#include <ranges>
+
+struct NonBorrowedRange {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(!std::ranges::enable_borrowed_range<NonBorrowedRange>);
+
+// Verify that if the expression is an rvalue and `enable_borrowed_range` is false, `ranges::rend` is ill-formed.
+void test() {
+  std::ranges::rend(NonBorrowedRange());
+  // expected-error-re@-1 {{{{call to deleted function call operator in type 'const (std::ranges::)?__rend::__fn'}}}}
+  // expected-error@-2  {{attempt to use a deleted function}}
+}

libcxx/test/std/ranges/range.access/size.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::size
+
+#include <ranges>
+
+extern int arr[];
+
+// Verify that for an array of unknown bound `ranges::size` is ill-formed.
+void test() {
+  std::ranges::size(arr);
+  // expected-error-re@-1 {{{{no matching function for call to object of type 'const (std::ranges::)?__size::__fn'}}}}
+}

libcxx/test/std/ranges/range.access/ssize.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::size
+
+#include <ranges>
+
+extern int arr[];
+
+// Verify that for an array of unknown bound `ranges::ssize` is ill-formed.
+void test() {
+  std::ranges::ssize(arr);
+  // expected-error-re@-1 {{{{no matching function for call to object of type 'const (std::ranges::)?__ssize::__fn'}}}}
+}

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

// Destination range is shorter than the source range, (range) overload.
     assert(Counted::total_copies == M);
     assert(Counted::total_moves == 0);
 
     assert(std::equal(in, in + M, out.begin(), out.end()));
     assert(result.in == in + M);
     assert(result.out == out.end());
   }
 
+  // Move-only iterators are supported.
+  {
+    using MoveOnlyIter = cpp20_input_iterator<const int*>;
+    static_assert(!std::is_copy_constructible_v<MoveOnlyIter>);
+
+    constexpr int N = 3;
+    struct MoveOnlyRange {
+      int buffer[N] = {1, 2, 3};
+      auto begin() const { return MoveOnlyIter(buffer); }
+      auto end() const { return sentinel_wrapper<MoveOnlyIter>(MoveOnlyIter(buffer)); }
+    };
+    static_assert(std::ranges::input_range<MoveOnlyRange>);
+    MoveOnlyRange in;
+
+    // (iter, sentinel) overload.
+    {
+      Buffer<int, N> out;
+      std::ranges::uninitialized_copy(in.begin(), in.end(), out.begin(), out.end());
+    }
+
+    // (range) overload.
+    {
+      Buffer<int, N> out;
+      std::ranges::uninitialized_copy(in, out);
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy_n.pass.cpp

 // uninitialized_copy_n_result<I, O> uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast); // since C++20
 
 #include <algorithm>
 #include <cassert>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
+#include <utility>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 // TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
// Destination range is shorter than the source range.
     assert(Counted::total_copies == M);
     assert(Counted::total_moves == 0);
 
     assert(std::equal(in, in + M, out.begin(), out.end()));
     assert(result.in == in + M);
     assert(result.out == out.end());
   }
 
+  // Move-only iterators are supported.
+  {
+    using MoveOnlyIter = cpp20_input_iterator<const int*>;
+    static_assert(!std::is_copy_constructible_v<MoveOnlyIter>);
+
+    constexpr int N = 3;
+    int buffer[N] = {1, 2, 3};
+
+    MoveOnlyIter in(buffer);
+    Buffer<int, N> out;
+    std::ranges::uninitialized_copy_n(std::move(in), N, out.begin(), out.end());
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp

// Ensure the `iter_move` customization point is being used.
     iter_moves = 0;
 
     std::ranges::subrange range(begin, end);
     std::ranges::uninitialized_move(range, out);
     assert(iter_moves == 3);
     iter_moves = 0;
   }
 
+  // Move-only iterators are supported.
+  {
+    using MoveOnlyIter = cpp20_input_iterator<const int*>;
+    static_assert(!std::is_copy_constructible_v<MoveOnlyIter>);
+
+    constexpr int N = 3;
+    struct MoveOnlyRange {
+      int buffer[N] = {1, 2, 3};
+      auto begin() const { return MoveOnlyIter(buffer); }
+      auto end() const { return sentinel_wrapper<MoveOnlyIter>(MoveOnlyIter(buffer)); }
+    };
+    static_assert(std::ranges::input_range<MoveOnlyRange>);
+    MoveOnlyRange in;
+
+    // (iter, sentinel) overload.
+    {
+      Buffer<int, N> out;
+      std::ranges::uninitialized_move(in.begin(), in.end(), out.begin(), out.end());
+    }
+
+    // (range) overload.
+    {
+      Buffer<int, N> out;
+      std::ranges::uninitialized_move(in, out);
+    }
+  }
+
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp

// Ensure the `iter_move` customization point is being used.
     iter_moves = 0;
 
     std::ranges::subrange range(begin, end);
     std::ranges::uninitialized_move(range, out);
     assert(iter_moves == 3);
     iter_moves = 0;
   }
 
+  // Move-only iterators are supported.
+  {
+    using MoveOnlyIter = cpp20_input_iterator<const int*>;
+    static_assert(!std::is_copy_constructible_v<MoveOnlyIter>);
+
+    constexpr int N = 3;
+    int buffer[N] = {1, 2, 3};
+
+    MoveOnlyIter in(buffer);
+    Buffer<int, N> out;
+    std::ranges::uninitialized_move_n(std::move(in), N, out.begin(), out.end());
+  }
+
   return 0;
 }