[libc++] Implement P2446R2 (views::as_rvalue)

[philnik]

Address Arthur's comments

[philnik]

Remove non-ASCII character

[philnik]

Add deduction guide

[huixie90]

libcxx/include/__ranges/as_rvalue_view.h

52

might be worth testing that if underlying iterator is already a move_iterator, this is calling the move constructor of move_iterator instead of creating a move_iterator<move_iterator<It>>

[ldionne]

@var-const Can you make a pass at this?

libcxx/include/__iterator/move_sentinel.h

53

Can you please add a simple test that exercises this ctad, even if it is the default-provided one by the compiler?

libcxx/include/__ranges/as_rvalue_view.h

62

Do you have tests for a simple view and a non-simple view?

75

Do you have tests for a common range and a non-common range?

95

Do you have a test that would fail if you dropped the all_t here?

104

This [[nodiscard]] is an extension, so it should be using _LIBCPP_NODISCARD_EXT unless I am mistaken. Please make sure we have a libc++ specific test for this extension.

We might be doing it wrong for other adaptors, in which case we should also fix them, but not in this patch.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp

91

Should we be using the new facilities with meta::for_each here? (everywhere)

libcxx/test/support/test_iterators.h

995

Any reason why this is not constexpr when it can be? (everywhere)

[var-const]

libcxx/include/__ranges/as_rvalue_view.h

4

Please update the <ranges> synopsis as well.

31

This needs an include (probably currently relying on the transitive include from all.h).

111–115

I think this (an optimization, essentially) deserves a comment.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/adaptor.pass.cpp

25

I think this check would be better in test_iterators.h, right after the definition of rvalue_iterator.

45

Can you also check piping a container (i.e. something that is not a view) through as_rvalue? Ideally, both lvalue and rvalue.

49

Nit: can you add empty lines between the cases? (Here and in some other tests)

53

s/auto/decltype(auto)/ (throughout).

56

The argument order is swapped in the comment.

74

Nit: return 0;.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp

30

These checks don't seem to be exhaustive. For example, there should probably be a check that !HasBegin if !range<const _View>.

33

This only tests the non-const version of begin, right? I think it shouldn't be too hard to also test a const as_rvalue_view here.

43

Optional: I think you could wrap this call in a check like if constexpr (std::sentinel_for<Iter, Iter>) and avoid having to call test_range directly from test.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp

59

s/Begin/End/.

62

Can you also test the case where the concept is false?

71

Is it possible to just use the std::ranges::common_range concept?

74

Same as the begin tests -- I think this should also test when a view is const.

81

Same as the begin test -- I think this can be simplified with if constexpr.

99

Why are we checking begin here?

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/size.pass.cpp

54

Doesn't seem to be checked. Also, why is it only on the const sized view and not the non-const one?

57

Why is the return value only checked for the const case?

[huixie90]

libcxx/include/__ranges/as_rvalue_view.h

35–37

do we have a test for this?

39

do we have a test for this? and a test for explicit?

[philnik]

Address comments

libcxx/include/__ranges/as_rvalue_view.h

111–115

I'm not sure what you mean? This is required by the standard.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp

71

Yes, but I'd rather avoid the meta-programming and just pass where it's expected to be a common range.

[var-const]

LGTM (with just a couple of minor comments). I'll leave final approval to @ldionne since he had comments as well.

libcxx/include/__ranges/as_rvalue_view.h

111–115

We can still add a comment, even if this is essentially copied from the Standard. If I'm reading this correctly, this avoids wrapping a range in an rvalue_view if it's already a range of rvalues, to avoid unnecessary bloat. If that's correct, I think it deserves a comment.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/ctor.pass.cpp

38

Would std::is_convertible work?

[philnik]

Address comments

[philnik]

libcxx/include/__ranges/as_rvalue_view.h

111–115

AFAIK lots of views do this, and we don't comment anywhere else. Adding a comment here makes it look like this is an extension.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/ctor.pass.cpp

38

Not for the default constructible case.

[ldionne]

libcxx/include/__iterator/move_sentinel.h

53

I don't think this was addressed. Please try to ensure that you've addressed feedback before marking a comment as done, otherwise it's really easy to drop (potentially important) comments on the floor. Reviewers usually assume that the feedback has been implemented correctly when the comment is marked as done.

libcxx/include/__ranges/as_rvalue_view.h

111–115

I would agree that no comment is needed since this is indeed what the standard specifies. I'm actually not sure what the comment would say.

[philnik]

Try to fix CI

[philnik]

• Try to fix CI
• Address comments

libcxx/docs/ReleaseNotes.rst

 - P2291R3 - Add Constexpr Modifiers to Functions ``to_chars`` and
   ``from_chars`` for Integral Types in ``<charconv>`` Header
 - P0220R1 - Adopt Library Fundamentals V1 TS Components for C++17
 - P0482R6 - char8_t: A type for UTF-8 characters and strings
 - P2438R2 - ``std::string::substr() &&``
 - P0600R1 - ``nodiscard`` in the library
 - P0339R6 - ``polymorphic_allocator<>`` as a vocabulary type
 - P1169R4 - ``static operator()``
+- P2446R2 - ``views::as_rvalue``
 
 Improvements and New Features
 -----------------------------
 - Declarations of ``std::c8rtomb()`` and ``std::mbrtoc8()`` from P0482R6 are
   now provided when implementations in the global namespace are provided by
   the C library.
 - Implemented ``<memory_resource>`` header from C++17
 

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2322R6 <https://wg21.link/P2322R6>`__","LWG","``ranges::fold``","July 2022","","","|ranges|"
 "`P2374R4 <https://wg21.link/P2374R4>`__","LWG","``views::cartesian_product``","July 2022","","","|ranges|"
 "`P2404R3 <https://wg21.link/P2404R3>`__","LWG","Move-only types for ``equality_comparable_with``, ``totally_ordered_with``, and ``three_way_comparable_with``","July 2022","",""
 "`P2408R5 <https://wg21.link/P2408R5>`__","LWG","Ranges iterators as inputs to non-Ranges algorithms","July 2022","","","|ranges|"
 "`P2417R2 <https://wg21.link/P2417R2>`__","LWG","A more ``constexpr`` ``bitset``","July 2022","|Complete|","16.0"
 "`P2419R2 <https://wg21.link/P2419R2>`__","LWG","Clarify handling of encodings in localized formatting of chrono types","July 2022","",""
 "`P2438R2 <https://wg21.link/P2438R2>`__","LWG","``std::string::substr() &&``","July 2022","|Complete|","16.0"
 "`P2445R1 <https://wg21.link/P2445R1>`__","LWG","``forward_like``","July 2022","|Complete|","16.0"
-"`P2446R2 <https://wg21.link/P2446R2>`__","LWG","``views::as_rvalue``","July 2022","","","|ranges|"
+"`P2446R2 <https://wg21.link/P2446R2>`__","LWG","``views::as_rvalue``","July 2022","|Complete|","16.0","|ranges|"
 "`P2460R2 <https://wg21.link/P2460R2>`__","LWG","Relax requirements on ``wchar_t`` to match existing practices","July 2022","",""
 "`P2465R3 <https://wg21.link/P2465R3>`__","LWG","Standard Library Modules ``std`` and ``std.compat``","July 2022","",""
 "`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"

libcxx/docs/Status/RangesViews.csv

 C++23,`zip_transform <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`adjacent <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`adjacent_transform <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`join_with <https://wg21.link/P2441R2>`_,Unassigned,No patch yet,Not started
 C++23,`slide <https://wg21.link/P2442R1>`_,Unassigned,No patch yet,Not started
 C++23,`chunk <https://wg21.link/P2442R1>`_,Unassigned,No patch yet,Not started
 C++23,`chunk_by <https://wg21.link/P2443R1>`_,Unassigned,No patch yet,Not started
 C++23,`as_const <https://wg21.link/P2278R4>`_,Unassigned,No patch yet,Not started
-C++23,`as_rvalue <https://wg21.link/P2446R2>`_,Nikolas Klauser,`D137637 <https://llvm.org/D137637>`_,Under review
+C++23,`as_rvalue <https://wg21.link/P2446R2>`_,Nikolas Klauser,`D137637 <https://llvm.org/D137637>`_,Complete
 C++23,`stride <https://wg21.link/P1899R3>`_,Unassigned,No patch yet,Not started

libcxx/include/CMakeLists.txt

set(files
   __random/student_t_distribution.h
   __random/subtract_with_carry_engine.h
   __random/uniform_int_distribution.h
   __random/uniform_random_bit_generator.h
   __random/uniform_real_distribution.h
   __random/weibull_distribution.h
   __ranges/access.h
   __ranges/all.h
+  __ranges/as_rvalue_view.h
   __ranges/common_view.h
   __ranges/concepts.h
   __ranges/copyable_box.h
   __ranges/counted.h
   __ranges/dangling.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/drop_while_view.h

libcxx/include/__iterator/move_sentinel.h

move_sentinel& operator=(const move_sentinel<_S2>& __s)
     { __last_ = __s.base(); return *this; }
 
   constexpr _Sent base() const { return __last_; }
 
 private:
     _Sent __last_ = _Sent();
 };
 
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_sentinel);
+
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_MOVE_SENTINEL_H

libcxx/include/__ranges/as_rvalue_view.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_AS_RVALUE_H
+#define _LIBCPP___RANGES_AS_RVALUE_H
+
+#include <__config>
+#include <__iterator/move_iterator.h>
+#include <__iterator/move_sentinel.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/view_interface.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+template <view _View>
+  requires input_range<_View>
+class as_rvalue_view : public view_interface<as_rvalue_view<_View>> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+
+public:
+  _LIBCPP_HIDE_FROM_ABI as_rvalue_view()
+    requires default_initializable<_View>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit as_rvalue_view(_View __base) : __base_(std::move(__base)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!__simple_view<_View>)
+  {
+    return move_iterator(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
+    return move_iterator(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
+    if constexpr (common_range<_View>) {
+      return move_iterator(ranges::end(__base_));
+    } else {
+      return move_sentinel(ranges::end(__base_));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
+    if constexpr (common_range<const _View>) {
+      return move_iterator(ranges::end(__base_));
+    } else {
+      return move_sentinel(ranges::end(__base_));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
+};
+
+template <class _Range>
+as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
+
+template <class _View>
+inline constexpr bool enable_borrowed_range<as_rvalue_view<_View>> = enable_borrowed_range<_View>;
+
+namespace views {
+namespace __as_rvalue {
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(/**/ as_rvalue_view(std::forward<_Range>(__range))))
+          -> decltype(/*--*/ as_rvalue_view(std::forward<_Range>(__range))) {
+    return /*-------------*/ as_rvalue_view(std::forward<_Range>(__range));
+  }
+
+  template <class _Range>
+    requires same_as<range_rvalue_reference_t<_Range>, range_reference_t<_Range>>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(/**/ views::all(std::forward<_Range>(__range))))
+          -> decltype(/*--*/ views::all(std::forward<_Range>(__range))) {
+    return /*-------------*/ views::all(std::forward<_Range>(__range));
+  }
+};
+} // namespace __as_rvalue
+
+inline namespace __cpo {
+constexpr auto as_rvalue = __as_rvalue::__fn{};
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___RANGES_AS_RVALUE_H

libcxx/include/ranges

template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
   class zip_view;        // C++2b
 
   template<class... Views>
     inline constexpr bool enable_borrowed_range<zip_view<Views...>> =    // C++2b
       (enable_borrowed_range<Views> && ...);
 
   namespace views { inline constexpr unspecified zip = unspecified; }    // C++2b
+
+  // [range.as.rvalue]
+  template <view V>
+    requires input_range<V>
+  class as_rvalue_view; // since C++23
+
+  namespace views { inline constexpr unspecified as_rvalue ) unspecified; } // since C++23
 }
 
 namespace std {
   namespace views = ranges::views;
 
   template<class T> struct tuple_size;
   template<size_t I, class T> struct tuple_element;
 
namespace std {
   };
 }
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
+#include <__ranges/as_rvalue_view.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/counted.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/drop_while_view.h>
 #include <__ranges/empty.h>

libcxx/test/libcxx/diagnostics/view_adaptors.nodiscard_extensions.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
+//
+//===----------------------------------------------------------------------===//
+
+// Check that view adaptors are marked [[nodiscard]] as a conforming extension
+
+// UNSUPPORTED: c++03, c++11, c++14 ,c++17
+
+#include <ranges>
+#include <vector>
+
+void func() {
+  std::vector<int> range;
+
+  auto rvalue_view = std::views::as_rvalue(range);
+  std::views::as_rvalue(range);         // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::views::as_rvalue(rvalue_view);   // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__random/student_t_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/student_t_distribution.h'}}
 #include <__random/subtract_with_carry_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/subtract_with_carry_engine.h'}}
 #include <__random/uniform_int_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_int_distribution.h'}}
 #include <__random/uniform_random_bit_generator.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_random_bit_generator.h'}}
 #include <__random/uniform_real_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_real_distribution.h'}}
 #include <__random/weibull_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/weibull_distribution.h'}}
 #include <__ranges/access.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/access.h'}}
 #include <__ranges/all.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/all.h'}}
+#include <__ranges/as_rvalue_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/as_rvalue_view.h'}}
 #include <__ranges/common_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/common_view.h'}}
 #include <__ranges/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/concepts.h'}}
 #include <__ranges/copyable_box.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/copyable_box.h'}}
 #include <__ranges/counted.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/counted.h'}}
 #include <__ranges/dangling.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/dangling.h'}}
 #include <__ranges/data.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/data.h'}}
 #include <__ranges/drop_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_view.h'}}
 #include <__ranges/drop_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_while_view.h'}}

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/adaptor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// std::views::as_rvalue
+
+#include <cassert>
+#include <functional>
+#include <ranges>
+#include <vector>
+
+#include "test_iterators.h"
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  int i_;
+  int* begin();
+  int* end();
+};
+
+struct RValueView : std::ranges::view_base {};
+
+template <class View, class T>
+concept HasPipe = requires(View&& view, T&& t) {
+  { std::forward<View>(view) | std::forward<T>(t) };
+};
+
+struct NoView {};
+static_assert(std::is_invocable_v<decltype(std::views::as_rvalue), DefaultConstructibleView>);
+static_assert(!std::is_invocable_v<decltype(std::views::as_rvalue)>);
+static_assert(!std::is_invocable_v<decltype(std::views::as_rvalue), NoView>);
+static_assert(HasPipe<DefaultConstructibleView&, decltype(std::views::as_rvalue)>);
+static_assert(HasPipe<int (&)[10], decltype(std::views::as_rvalue)>);
+static_assert(!HasPipe<int (&&)[10], decltype(std::views::as_rvalue)>);
+static_assert(!HasPipe<NoView, decltype(std::views::as_rvalue)>);
+static_assert(std::is_same_v<decltype(std::views::as_rvalue), decltype(std::ranges::views::as_rvalue)>);
+
+struct move_iterator_range {
+  constexpr std::move_iterator<int*> begin() const { return {}; }
+  constexpr std::move_iterator<int*> end() const { return {}; }
+};
+
+static_assert(!std::ranges::view<move_iterator_range>);
+static_assert(std::ranges::range<move_iterator_range>);
+
+constexpr bool test() {
+  { // view | views::as_rvalue
+    DefaultConstructibleView v{{}, 3};
+    std::same_as<std::ranges::as_rvalue_view<DefaultConstructibleView>> decltype(auto) view = v | std::views::as_rvalue;
+    assert(view.base().i_ == 3);
+  }
+
+  { // adaptor | views::as_rvalue
+    DefaultConstructibleView v{{}, 3};
+    const auto partial = std::views::transform(std::identity{}) | std::views::as_rvalue;
+    std::same_as<std::ranges::as_rvalue_view<
+        std::ranges::transform_view<DefaultConstructibleView, std::identity>>> decltype(auto) view = partial(v);
+    assert(view.base().base().i_ == 3);
+  }
+
+  { // views::as_rvalue | adaptor
+    DefaultConstructibleView v{{}, 3};
+    const auto partial = std::views::as_rvalue | std::views::transform(std::identity{});
+    std::same_as<std::ranges::transform_view<std::ranges::as_rvalue_view<DefaultConstructibleView>,
+                                             std::identity>> decltype(auto) view = partial(v);
+    assert(view.base().base().i_ == 3);
+  }
+
+  { // rvalue-view | views::as_rvalue
+    int a[4] = {1, 2, 3, 4};
+    std::ranges::subrange range(rvalue_iterator(a), rvalue_iterator(a + 4));
+    [[maybe_unused]] std::same_as<std::ranges::subrange<rvalue_iterator<int>>> decltype(auto) rval_range =
+        range | std::views::as_rvalue;
+  }
+
+  { // range | views::as_rvalue
+    [[maybe_unused]] std::same_as<std::ranges::as_rvalue_view<std::views::all_t<std::vector<int>>>> decltype(auto)
+        view = std::vector<int>{} | std::views::as_rvalue;
+  }
+
+  { // rvalue-range | views::as_rvalue
+    [[maybe_unused]] std::same_as<std::views::all_t<move_iterator_range>> decltype(auto) view =
+        move_iterator_range{} | std::views::as_rvalue;
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/base.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr V base() const & requires copy_constructible<V> { return base_; }
+// constexpr V base() && { return std::move(base_); }
+
+#include <cassert>
+#include <ranges>
+
+#include "MoveOnly.h"
+
+struct SimpleView : std::ranges::view_base {
+  int i;
+  int* begin() const;
+  int* end() const;
+};
+
+struct MoveOnlyView : SimpleView {
+  MoveOnly m;
+};
+
+template <class T>
+concept HasBase = requires(T&& t) { std::forward<T>(t).base(); };
+
+static_assert(HasBase<std::ranges::as_rvalue_view<SimpleView> const&>);
+static_assert(HasBase<std::ranges::as_rvalue_view<SimpleView>&&>);
+
+static_assert(!HasBase<std::ranges::as_rvalue_view<MoveOnlyView> const&>);
+static_assert(HasBase<std::ranges::as_rvalue_view<MoveOnlyView>&&>);
+
+constexpr bool test() {
+  { // const &
+    const std::ranges::as_rvalue_view<SimpleView> view(SimpleView{{}, 5});
+    std::same_as<SimpleView> decltype(auto) v = view.base();
+    assert(v.i == 5);
+  }
+
+  { // &
+    std::ranges::as_rvalue_view<SimpleView> view(SimpleView{{}, 5});
+    std::same_as<SimpleView> decltype(auto) v = view.base();
+    assert(v.i == 5);
+  }
+
+  { // &&
+    std::ranges::as_rvalue_view<SimpleView> view(SimpleView{{}, 5});
+    std::same_as<SimpleView> decltype(auto) v = std::move(view).base();
+    assert(v.i == 5);
+  }
+
+  { // const &&
+    const std::ranges::as_rvalue_view<SimpleView> view(SimpleView{{}, 5});
+    std::same_as<SimpleView> decltype(auto) v = std::move(view).base();
+    assert(v.i == 5);
+  }
+
+  { // move only
+    std::ranges::as_rvalue_view<MoveOnlyView> view(MoveOnlyView{{}, 5});
+    std::same_as<MoveOnlyView> decltype(auto) v = std::move(view).base();
+    assert(v.m.get() == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr auto begin()
+// constexpr auto begin() const
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <ranges>
+
+#include "test_iterators.h"
+
+struct SimpleView : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+struct NonSimpleView : std::ranges::view_base {
+  char* begin();
+  char* end();
+  int* begin() const;
+  int* end() const;
+};
+
+struct NonConstView : std::ranges::view_base {
+  char* begin();
+  char* end();
+};
+
+template <class T>
+concept HasBegin = requires(T t) { t.begin(); };
+
+static_assert(HasBegin<std::ranges::as_rvalue_view<SimpleView>>);
+static_assert(HasBegin<const std::ranges::as_rvalue_view<SimpleView>>);
+static_assert(HasBegin<std::ranges::as_rvalue_view<NonSimpleView>>);
+static_assert(HasBegin<const std::ranges::as_rvalue_view<NonSimpleView>>);
+static_assert(HasBegin<std::ranges::as_rvalue_view<NonConstView>>);
+static_assert(!HasBegin<const std::ranges::as_rvalue_view<NonConstView>>);
+
+template <class Iter, class Sent>
+constexpr void test_range() {
+  int a[] = {1, 2};
+  std::ranges::subrange range(Iter(std::begin(a)), Sent(Iter(std::end(a))));
+  std::ranges::as_rvalue_view view(std::move(range));
+  std::same_as<std::move_iterator<Iter>> decltype(auto) iter = view.begin();
+  assert(base(iter.base()) == std::begin(a));
+}
+
+template <class Iter, class Sent>
+class WrapRange {
+  Iter iter_;
+  Sent sent_;
+
+public:
+  constexpr WrapRange(Iter iter, Sent sent) : iter_(std::move(iter)), sent_(std::move(sent)) {}
+
+  constexpr Iter begin() const { return iter_; }
+  constexpr Sent end() const { return sent_; }
+};
+
+template <class Iter, class Sent>
+WrapRange(Iter, Sent) -> WrapRange<Iter, Sent>;
+
+template <class Iter, class Sent>
+constexpr void test_const_range() {
+  int a[]    = {1, 2};
+  auto range = WrapRange{Iter(a), Sent(Iter(a + 2))};
+  const std::ranges::as_rvalue_view view(std::views::all(range));
+  std::same_as<std::move_iterator<Iter>> decltype(auto) iter = view.begin();
+  assert(base(iter.base()) == std::begin(a));
+}
+
+struct move_iterator_view : std::ranges::view_base {
+  constexpr std::move_iterator<int*> begin() const { return {}; }
+  constexpr std::move_iterator<int*> end() const { return {}; }
+};
+
+constexpr bool test() {
+  meta::for_each(meta::cpp20_input_iterator_list<int*>{}, []<class Iter> {
+    if constexpr (std::sentinel_for<Iter, Iter>)
+      test_range<Iter, Iter>();
+    test_range<Iter, sentinel_wrapper<Iter>>();
+    test_range<Iter, sized_sentinel<Iter>>();
+  });
+
+  meta::for_each(meta::forward_iterator_list<const int*>{}, []<class Iter> {
+    test_const_range<Iter, Iter>();
+    test_const_range<Iter, sentinel_wrapper<Iter>>();
+    test_const_range<Iter, sized_sentinel<Iter>>();
+  });
+
+  { // check that with a std::move_iterator begin() doesn't return move_iterator<move_iterator<T>>
+    std::ranges::as_rvalue_view view{move_iterator_view{}};
+    std::same_as<std::move_iterator<int*>> decltype(auto) it = view.begin();
+    assert(it == std::move_iterator<int*>{});
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/ctad.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <ranges>
+#include <vector>
+#include <utility>
+
+static_assert(std::is_same_v<decltype(std::ranges::as_rvalue_view(std::vector<int>{})),
+                             std::ranges::as_rvalue_view<std::views::all_t<std::vector<int>>>>);
+
+static_assert(std::is_same_v<decltype(std::ranges::as_rvalue_view(std::declval<std::vector<int>&>())),
+                             std::ranges::as_rvalue_view<std::views::all_t<std::vector<int>&>>>);
+
+static_assert(std::is_same_v<decltype(std::ranges::as_rvalue_view(std::ranges::empty_view<int>{})),
+                             std::ranges::as_rvalue_view<std::ranges::empty_view<int>>>);

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/ctor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// std::ranges::as_rvalue_view::as_rvalue_view(...)
+
+#include <cassert>
+#include <ranges>
+#include <vector>
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+
+  int i_ = 23;
+};
+
+struct NonDefaultConstructibleView : std::ranges::view_base {
+  NonDefaultConstructibleView(int i) : i_(i) {}
+
+  int* begin() const;
+  int* end() const;
+
+  int i_ = 23;
+};
+
+static_assert(!std::is_constructible_v<std::ranges::as_rvalue_view<NonDefaultConstructibleView>>);
+static_assert(std::is_constructible_v<std::ranges::as_rvalue_view<NonDefaultConstructibleView>, int>);
+static_assert(std::is_nothrow_constructible_v<std::ranges::as_rvalue_view<DefaultConstructibleView>>);
+
+template <class T, class... Args>
+concept IsImplicitlyConstructible = requires(T val, Args... args) { val = {std::forward<Args>(args)...}; };
+
+static_assert(IsImplicitlyConstructible<std::ranges::as_rvalue_view<DefaultConstructibleView>>);
+static_assert(!IsImplicitlyConstructible<std::ranges::as_rvalue_view<NonDefaultConstructibleView>, int>);
+
+constexpr bool test() {
+  std::ranges::as_rvalue_view<DefaultConstructibleView> view = {};
+  assert(view.base().i_ == 23);
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test());
+  test();
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/enable_borrowed_range.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <ranges>
+#include <vector>
+
+static_assert(std::ranges::enable_borrowed_range<std::ranges::as_rvalue_view<std::ranges::empty_view<int>>>);
+static_assert(std::ranges::enable_borrowed_range<std::ranges::as_rvalue_view<std::views::all_t<std::vector<int>&>>>);
+static_assert(!std::ranges::enable_borrowed_range<std::ranges::as_rvalue_view<std::views::all_t<std::vector<int>>>>);

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr auto end()
+// constexpr auto end() const
+
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+struct CVCallView : std::ranges::view_base {
+  mutable bool const_called = false;
+  mutable int i[1];
+  constexpr int* begin() {
+    const_called = false;
+    return i;
+  }
+
+  constexpr int* begin() const {
+    const_called = true;
+    return i;
+  }
+
+  constexpr int* end() {
+    const_called = false;
+    return i + 1;
+  }
+
+  constexpr int* end() const {
+    const_called = true;
+    return i + 1;
+  }
+};
+
+struct NonConstCommonRange : std::ranges::view_base {
+  int* begin();
+  int* end();
+
+  int* begin() const;
+  sentinel_wrapper<int*> end() const;
+};
+
+struct NonConstView : std::ranges::view_base {
+  int* begin();
+  int* end();
+};
+
+template <class T>
+concept HasEnd = requires(T t) { t.end(); };
+
+static_assert(HasEnd<std::ranges::as_rvalue_view<DefaultConstructibleView>>);
+static_assert(HasEnd<const std::ranges::as_rvalue_view<DefaultConstructibleView>>);
+static_assert(HasEnd<std::ranges::as_rvalue_view<NonConstView>>);
+static_assert(!HasEnd<const std::ranges::as_rvalue_view<NonConstView>>);
+
+static_assert(std::is_same_v<decltype(std::declval<std::ranges::as_rvalue_view<DefaultConstructibleView>>().end()),
+                             std::move_iterator<int*>>);
+static_assert(std::is_same_v<decltype(std::declval<const std::ranges::as_rvalue_view<NonConstCommonRange>>().end()),
+                             std::move_sentinel<sentinel_wrapper<int*>>>);
+
+template <class Iter, class Sent, bool is_common>
+constexpr void test_range() {
+  using Expected = std::conditional_t<is_common, std::move_iterator<Sent>, std::move_sentinel<Sent>>;
+  int a[]        = {1, 2};
+  std::ranges::subrange range(Iter(std::begin(a)), Sent(Iter(std::end(a))));
+  std::ranges::as_rvalue_view view(std::move(range));
+  std::same_as<Expected> decltype(auto) iter = view.end();
+  assert(base(base(iter.base())) == std::end(a));
+}
+
+template <class Iter, class Sent>
+class WrapRange {
+  Iter iter_;
+  Sent sent_;
+
+public:
+  constexpr WrapRange(Iter iter, Sent sent) : iter_(std::move(iter)), sent_(std::move(sent)) {}
+
+  constexpr Iter begin() const { return iter_; }
+  constexpr Sent end() const { return sent_; }
+};
+
+template <class Iter, class Sent>
+WrapRange(Iter, Sent) -> WrapRange<Iter, Sent>;
+
+template <class Iter, class Sent, bool is_common>
+constexpr void test_const_range() {
+  using Expected = std::conditional_t<is_common, std::move_iterator<Sent>, std::move_sentinel<Sent>>;
+  int a[]        = {1, 2};
+  auto range = WrapRange{Iter(a), Sent(Iter(a + 2))};
+  const std::ranges::as_rvalue_view view(std::move(range));
+  std::same_as<Expected> decltype(auto) iter = view.end();
+  assert(base(base(iter.base())) == std::end(a));
+}
+
+struct move_iterator_view : std::ranges::view_base {
+  constexpr std::move_iterator<int*> begin() const { return {}; }
+  constexpr std::move_iterator<int*> end() const { return {}; }
+};
+
+constexpr bool test() {
+  test_range<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>, false>();
+  test_range<cpp17_input_iterator<int*>, sized_sentinel<cpp17_input_iterator<int*>>, false>();
+  test_range<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>, false>();
+  test_range<cpp20_input_iterator<int*>, sized_sentinel<cpp20_input_iterator<int*>>, false>();
+
+  meta::for_each(meta::forward_iterator_list<int*>{}, []<class Iter> {
+    test_range<Iter, Iter, true>();
+    test_range<Iter, sentinel_wrapper<Iter>, false>();
+    test_range<Iter, sized_sentinel<Iter>, false>();
+  });
+
+  {
+    std::ranges::as_rvalue_view view(CVCallView{});
+    (void)view.end();
+    assert(view.base().const_called);
+  }
+
+  { // check that with a std::move_iterator begin() doesn't return move_iterator<move_iterator<T>>
+    std::ranges::as_rvalue_view view{move_iterator_view{}};
+    std::same_as<std::move_iterator<int*>> decltype(auto) it = view.end();
+    assert(it == std::move_iterator<int*>{});
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/size.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
+//
+//===----------------------------------------------------------------------===//
+
+// constexpr auto size()
+// constexpr auto size() const
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <cstddef>
+#include <ranges>
+
+struct ConstSizedView : std::ranges::view_base {
+  bool* size_called;
+  int* begin() const;
+  int* end() const;
+
+  constexpr size_t size() const {
+    *size_called = true;
+    return 3;
+  }
+};
+
+struct SizedView : std::ranges::view_base {
+  bool* size_called;
+  int* begin() const;
+  int* end() const;
+
+  constexpr int size() {
+    *size_called = true;
+    return 5;
+  }
+};
+
+struct UnsizedView : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+template <class T>
+concept HasSize = requires(T v) { v.size(); };
+
+static_assert(HasSize<ConstSizedView>);
+static_assert(HasSize<const ConstSizedView>);
+static_assert(HasSize<SizedView>);
+static_assert(!HasSize<const SizedView>);
+static_assert(!HasSize<UnsizedView>);
+static_assert(!HasSize<const UnsizedView>);
+
+constexpr bool test() {
+  {
+    bool size_called = false;
+    std::ranges::as_rvalue_view view(ConstSizedView{{}, &size_called});
+    std::same_as<size_t> auto size = view.size();
+    assert(size == 3);
+    assert(size_called);
+  }
+
+  {
+    bool size_called = false;
+    std::ranges::as_rvalue_view view(SizedView{{}, &size_called});
+    std::same_as<int> auto size = view.size();
+    assert(size == 5);
+    assert(size_called);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/support/test_iterators.h

public:
   }
   constexpr friend auto operator<=>(const Iterator& lhs, const Iterator& rhs) {
     return lhs.ptr_ <=> rhs.ptr_;
   }
 };
 
 } // namespace adl
 
+template <class T>
+class rvalue_iterator {
+public:
+  using iterator_category = std::input_iterator_tag;
+  using iterator_concept  = std::random_access_iterator_tag;
+  using difference_type   = std::ptrdiff_t;
+  using reference         = T&&;
+  using value_type        = T;
+
+  rvalue_iterator() = default;
+  constexpr rvalue_iterator(T* it) : it_(it) {}
+
+  constexpr reference operator*() const { return std::move(*it_); }
+
+  constexpr rvalue_iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+
+  constexpr rvalue_iterator operator++(int) {
+    auto tmp = *this;
+    ++it_;
+    return tmp;
+  }
+
+  constexpr rvalue_iterator& operator--() {
+    --it_;
+    return *this;
+  }
+
+  constexpr rvalue_iterator operator--(int) {
+    auto tmp = *this;
+    --it_;
+    return tmp;
+  }
+
+  constexpr rvalue_iterator operator+(difference_type n) const {
+    auto tmp = *this;
+    tmp.it += n;
+    return tmp;
+  }
+
+  constexpr friend rvalue_iterator operator+(difference_type n, rvalue_iterator iter) {
+    iter += n;
+    return iter;
+  }
+
+  constexpr rvalue_iterator operator-(difference_type n) const {
+    auto tmp = *this;
+    tmp.it -= n;
+    return tmp;
+  }
+
+  constexpr difference_type operator-(const rvalue_iterator& other) const { return it_ - other.it_; }
+
+  constexpr rvalue_iterator& operator+=(difference_type n) {
+    it_ += n;
+    return *this;
+  }
+
+  constexpr rvalue_iterator& operator-=(difference_type n) {
+    it_ -= n;
+    return *this;
+  }
+
+  constexpr reference operator[](difference_type n) const { return std::move(it_[n]); }
+
+  auto operator<=>(const rvalue_iterator&) const noexcept = default;
+
+private:
+  T* it_;
+};
+
+template <class T>
+rvalue_iterator(T*) -> rvalue_iterator<T>;
+
+static_assert(std::random_access_iterator<rvalue_iterator<int*>>);
+
 // Proxy
 // ======================================================================
 // Proxy that can wrap a value or a reference. It simulates C++23's tuple
 // but simplified to just hold one argument.
 // Note that unlike tuple, this class deliberately doesn't have special handling
 // of swap to cause a compilation error if it's used in an algorithm that relies
 // on plain swap instead of ranges::iter_swap.
 // This class is useful for testing that if algorithms support proxy iterator