[libc++][ranges] Implement P2494R2 (Relaxing range adaptors to allow for move only types)

[yronglin]

Summary

Implement P2494R2 Relaxing range adaptors to allow for move only types

https://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2494r2.html#wording-ftm

According to the words in P2494R2, I haven't add new test for drop_while_view, take_while_view and filter_view, because these views has the requirement that the predicate is an indirect_unary_predicate, which requires that the predicate is copy_constructible, so they still can't accept move only types as predicate.

[P2483R0] also suggests future work to relax the requirements on the predicate types stored by standard views. This paper does not perform this relaxation, as the copy constructibility requirement is enshrined in the indirect callable concepts ([indirectcallable.indirectinvocable]). Thus, while this paper modifies the views that currently use copyable-box for user provided predicates, it only does so to apply the rename of the exposition-only type to movable-box; it does not change any of the constraints on those views. It does, however, relax the requirements on invocables accepted by the transform family of views, because those are not constrained using the indirect callable concepts.

[yronglin]

Try fix CI.

[yronglin]

try fix ci

[yronglin]

Fix CI

[yronglin]

Remove extra format change.

[yronglin]

Fix ci.

[yronglin]

ping~

[Mordante]

I mainly glossed over it. I'm not to familiar with the details of these internals of ranges.

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/properties.compile.pass.cpp

12

[yronglin]

Address comments

[yronglin]

Thanks for your review @Mordante !

[var-const]

Thanks for the patch!

libcxx/include/__ranges/filter_view.h

56

For each of these changes to existing views, we need a new test(s) that would fail if not for the change in this patch.

libcxx/include/__ranges/movable_box.h

11

The formatting changes make it harder to see things that are relevant to the proposal in this file. Can you clang-format copyable_box.h in a separate patch and rebase this patch on that?

34

Is this comment up-to-date?

45

Is there a reason not to apply the new behavior to old language versions retroactively? Would this change break any existing code?

(Also tagging @ldionne )

libcxx/include/__ranges/single_view.h

34

Can you please undo the formatting change? It makes it harder to see the parts of the diff that implement the proposal.

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/arrow.pass.cpp

11

s/copyable-box/movable-box/. Applies throughout.

[var-const]

Do you need to also bump #define __cpp_lib_ranges ?

[yronglin]

Sorry for the late reply and thanks a lot for your review! @var-const

libcxx/include/__ranges/movable_box.h

11

Ok, I'll rename copyable_box.h -> movable_box.h and formart in a separate patch.

34

Oops, It need update.

libcxx/include/__ranges/single_view.h

34

OK, I'll undo format changes,

[yronglin]

In D151629#4392402, @var-const wrote:

Do you need to also bump #define __cpp_lib_ranges ?

Good catch! __cpp_lib_ranges need update to 202207L

[ldionne]

libcxx/include/__ranges/movable_box.h

45

https://github.com/cplusplus/papers/issues/1156 is not super clear as to whether this should be treated as a DR.

@jwakely @CaseyCarter what did you folks do here? Did you apply P2494R2 (copyable-box => movable-box) as a DR to C++20, or do you consider it as a C++23 feature?

[jwakely]

libcxx/include/__ranges/movable_box.h

45

https://github.com/cplusplus/papers/issues/1156 is not super clear as to whether this should be treated as a DR.

Good, I prefer to leave that to implementors where there's no compelling reason it has to be a DR. IMHO there's no defect here, this is a design change. It's an improvement, but the previous design was sound, not buggy.

@jwakely @CaseyCarter what did you folks do here? Did you apply P2494R2 (copyable-box => movable-box) as a DR to C++20, or do you consider it as a C++23 feature?

We didn't do it yet, but I think it looks harmless to apply the change to C++20 instead of making it conditional.

[yronglin]

Undo format changes and add tests for move only types.

The header file was not renamed, and still __copyable_box.h, this makes the review more convenient, I will rename files and dirs after reviews done or in a separate patch.

Due to the words in P2494R2, I haven't add new test for drop_while_view, take_while_view and filter_view, because these views has the requirement that the predicate is an indirect_unary_predicate, which requires that the predicate is copy_constructible, so they still can't accept move only types as predicate.

[P2483R0] also suggests future work to relax the requirements on the predicate types stored by standard views. This paper does not perform this relaxation, as the copy constructibility requirement is enshrined in the indirect callable concepts ([indirectcallable.indirectinvocable]). Thus, while this paper modifies the views that currently use copyable-box for user provided predicates, it only does so to apply the rename of the exposition-only type to movable-box; it does not change any of the constraints on those views. It does, however, relax the requirements on invocables accepted by the transform family of views, because those are not constrained using the indirect callable concepts.

[yronglin]

Thanks for your review, @var-const @ldionne @jwakely !

[yronglin]

Fix feature test macro

[yronglin]

In D151629#4392402, @var-const wrote:

Do you need to also bump #define __cpp_lib_ranges ?

Thanks, done.

[yronglin]

ping～

[H-G-Hristov]

Normally the "Build Status" looks like this:

Buildable 237942
Build 368504: pre-merge checks
Build 368503: arc lint + arc unit

And here it is missing the last line. Is this some sort of CI issue?

Build Status
Buildable 237526
Build 367796: pre-merge checks

[yronglin]

In D151629#4411417, @H-G-Hristov wrote:

Normally the "Build Status" looks like this:

Buildable 237942
Build 368504: pre-merge checks
Build 368503: arc lint + arc unit

And here it is missing the last line. Is this some sort of CI issue?

Build Status
Buildable 237526
Build 367796: pre-merge checks

This looks weird, and I'm not sure what's going on, but it looks like the test results are looks good https://buildkite.com/llvm-project/diff-checks/builds/177081

[yronglin]

ping~

[CaseyCarter]

libcxx/include/__ranges/movable_box.h

45

We did _not_ apply to C++20 (https://github.com/microsoft/STL/pull/2965/files#diff-522242e575c221b356ad37137cf877b2a4b4a5de24333f834cf4f981560dd7ecR49-R56), but I could very easily be convinced that we should.

[yronglin]

libcxx/include/__ranges/movable_box.h

45

Ahhh, thanks for your reply! Will you apply this change for c++20 in libstdc++ and microsoft/STL in the future?

[ldionne]

libcxx/include/__ranges/movable_box.h

45

Looks like there's no strong reason to do it for C++20. I agree with @jwakely that this is not a "bug fix". So then I recommend we implement it as a new feature for C++23.

We can still rename the class to __movable_box while adding a comment that it actually requires copyability pre C++23.

[yronglin]

Relaxing range adaptors to allow for move only types since C++23.

[yronglin]

Fix ci

[yronglin]

ping～

[var-const]

Almost LGTM. Please also rename copyable_box.h to movable_box.h and I think this patch should be good to go.

libcxx/include/__ranges/copyable_box.h

1

Nit: consider rephrasing this so that it's written from the perspective of the new state, not the previous state. That is, instead of saying "we allow this since C++23", consider saying "this wasn't allowed before C++23". Perhaps something like:

Note: until C++23, `__movable_box` was named `__copyable_box` and required the stored type to be copy-constructible, not just move-constructible; we preserve the old behavior in pre-C++23 modes.

libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp

106

Nit: we usually rely on the compiler deducing the size of the array from the initializer.

[yronglin]

Rename file name from copyable_box.h to movable_box.h

[yronglin]

In D151629#4439512, @var-const wrote:

Almost LGTM. Please also rename copyable_box.h to movable_box.h and I think this patch should be good to go.

Thanks for your review!

[yronglin]

Try fix ci.

[var-const]

Thank you for working on this!

[yronglin]

Thanks for your review! once the CI green, I'll land this patch.

[yronglin]

fix ci

[yronglin]

NFC

• Rename directory name from range.copy.warp to range.move.warp
• Format

[yronglin]

Fix ci.

[yronglin]

The windows CI failure seems not caused by this patch, I think it caused by D153656

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__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_ranges``                                ``202207L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_remove_cvref``                          ``201711L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_semaphore``                             ``201907L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_shared_ptr_arrays``                     ``201707L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_shift``                                 ``201806L``

libcxx/docs/Status/Cxx23Papers.csv

 "`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","|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|"
+"`P2494R2 <https://wg21.link/P2494R2>`__","LWG","Relaxing range adaptors to allow for move only types","July 2022","|Complete|","17.0","|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","|Complete| [#note-P2520R0]_","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"

libcxx/include/CMakeLists.txt

set(files
   __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/container_compatible_range.h
-  __ranges/copyable_box.h
   __ranges/counted.h
   __ranges/dangling.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/drop_while_view.h
   __ranges/elements_view.h
   __ranges/empty.h
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/filter_view.h
   __ranges/from_range.h
   __ranges/iota_view.h
   __ranges/istream_view.h
   __ranges/join_view.h
   __ranges/lazy_split_view.h
+  __ranges/movable_box.h
   __ranges/non_propagating_cache.h
   __ranges/owning_view.h
   __ranges/range_adaptor.h
   __ranges/rbegin.h
   __ranges/ref_view.h
   __ranges/rend.h
   __ranges/reverse_view.h
   __ranges/single_view.h

libcxx/include/__ranges/copyable_box.h

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___RANGES_COPYABLE_BOX_H
-#define _LIBCPP___RANGES_COPYABLE_BOX_H
-
-#include <__concepts/constructible.h>
-#include <__concepts/copyable.h>
-#include <__concepts/movable.h>
-#include <__config>
-#include <__memory/addressof.h>
-#include <__memory/construct_at.h>
-#include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__utility/move.h>
-#include <optional>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 20
-
-// __copyable_box allows turning a type that is copy-constructible (but maybe not copy-assignable) into
-// a type that is both copy-constructible and copy-assignable. It does that by introducing an empty state
-// and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary
-// to handle the case where the copy construction fails after destroying the object.
-//
-// In some cases, we can completely avoid the use of an empty state; we provide a specialization of
-// __copyable_box that does this, see below for the details.
-
-template<class _Tp>
-concept __copy_constructible_object = copy_constructible<_Tp> && is_object_v<_Tp>;
-
-namespace ranges {
-  // Primary template - uses std::optional and introduces an empty state in case assignment fails.
-  template<__copy_constructible_object _Tp>
-  class __copyable_box {
-    _LIBCPP_NO_UNIQUE_ADDRESS optional<_Tp> __val_;
-
-  public:
-    template<class ..._Args>
-      requires is_constructible_v<_Tp, _Args...>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
-      noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
-      : __val_(in_place, std::forward<_Args>(__args)...)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
-      requires default_initializable<_Tp>
-      : __val_(in_place)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box const& __other)
-      noexcept(is_nothrow_copy_constructible_v<_Tp>)
-    {
-      if (this != std::addressof(__other)) {
-        if (__other.__has_value()) __val_.emplace(*__other);
-        else                       __val_.reset();
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box&& __other)
-      noexcept(is_nothrow_move_constructible_v<_Tp>)
-    {
-      if (this != std::addressof(__other)) {
-        if (__other.__has_value()) __val_.emplace(std::move(*__other));
-        else                       __val_.reset();
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return *__val_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return *__val_; }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return __val_.operator->(); }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return __val_.operator->(); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return __val_.has_value(); }
-  };
-
-  // This partial specialization implements an optimization for when we know we don't need to store
-  // an empty state to represent failure to perform an assignment. For copy-assignment, this happens:
-  //
-  // 1. If the type is copyable (which includes copy-assignment), we can use the type's own assignment operator
-  //    directly and avoid using std::optional.
-  // 2. If the type is not copyable, but it is nothrow-copy-constructible, then we can implement assignment as
-  //    destroy-and-then-construct and we know it will never fail, so we don't need an empty state.
-  //
-  // The exact same reasoning can be applied for move-assignment, with copyable replaced by movable and
-  // nothrow-copy-constructible replaced by nothrow-move-constructible. This specialization is enabled
-  // whenever we can apply any of these optimizations for both the copy assignment and the move assignment
-  // operator.
-  template<class _Tp>
-  concept __doesnt_need_empty_state_for_copy = copyable<_Tp> || is_nothrow_copy_constructible_v<_Tp>;
-
-  template<class _Tp>
-  concept __doesnt_need_empty_state_for_move = movable<_Tp> || is_nothrow_move_constructible_v<_Tp>;
-
-  template<__copy_constructible_object _Tp>
-    requires __doesnt_need_empty_state_for_copy<_Tp> && __doesnt_need_empty_state_for_move<_Tp>
-  class __copyable_box<_Tp> {
-    _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
-
-  public:
-    template<class ..._Args>
-      requires is_constructible_v<_Tp, _Args...>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
-      noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
-      : __val_(std::forward<_Args>(__args)...)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
-      requires default_initializable<_Tp>
-      : __val_()
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
-
-    // Implementation of assignment operators in case we perform optimization (1)
-    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box const&) requires copyable<_Tp> = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
-
-    // Implementation of assignment operators in case we perform optimization (2)
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box const& __other) noexcept {
-      static_assert(is_nothrow_copy_constructible_v<_Tp>);
-      if (this != std::addressof(__other)) {
-        std::destroy_at(std::addressof(__val_));
-        std::construct_at(std::addressof(__val_), __other.__val_);
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box&& __other) noexcept {
-      static_assert(is_nothrow_move_constructible_v<_Tp>);
-      if (this != std::addressof(__other)) {
-        std::destroy_at(std::addressof(__val_));
-        std::construct_at(std::addressof(__val_), std::move(__other.__val_));
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return __val_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return __val_; }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return std::addressof(__val_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return std::addressof(__val_); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
-  };
-} // namespace ranges
-
-#endif // _LIBCPP_STD_VER >= 20
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___RANGES_COPYABLE_BOX_H

libcxx/include/__ranges/drop_while_view.h

 #include <__concepts/constructible.h>
 #include <__config>
 #include <__functional/bind_back.h>
 #include <__functional/reference_wrapper.h>
 #include <__iterator/concepts.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
 #include <__ranges/enable_borrowed_range.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_object.h>
 #include <__utility/forward.h>
if constexpr (_UseCache) {
       return ranges::find_if_not(__base_, std::cref(*__pred_));
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr auto end() { return ranges::end(__base_); }
 
 private:
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
   static constexpr bool _UseCache = forward_range<_View>;
   using _Cache                    = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
   _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
 };
 
 template <class _View, class _Pred>
 inline constexpr bool enable_borrowed_range<drop_while_view<_View, _Pred>> = enable_borrowed_range<_View>;

libcxx/include/__ranges/filter_view.h

 #include <__iterator/concepts.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_object.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
   template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
     requires view<_View> && is_object_v<_Pred>
   class filter_view : public view_interface<filter_view<_View, _Pred>> {
     _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-    _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+    _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
     // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
     // the underlying range is at least a forward_range.
     static constexpr bool _UseCache = forward_range<_View>;
     using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
     _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
 
     class __iterator;

libcxx/include/__ranges/iota_view.h

 #include <__concepts/semiregular.h>
 #include <__concepts/totally_ordered.h>
 #include <__config>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/unreachable_sentinel.h>
-#include <__ranges/copyable_box.h>
 #include <__ranges/enable_borrowed_range.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_nothrow_copy_constructible.h>
 #include <__type_traits/make_unsigned.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 

libcxx/include/__ranges/movable_box.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_MOVABLE_BOX_H
+#define _LIBCPP___RANGES_MOVABLE_BOX_H
+
+#include <__concepts/constructible.h>
+#include <__concepts/copyable.h>
+#include <__concepts/movable.h>
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_nothrow_copy_constructible.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__utility/move.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+// __movable_box allows turning a type that is move-constructible (but maybe not move-assignable) into
+// a type that is both move-constructible and move-assignable. It does that by introducing an empty state
+// and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary
+// to handle the case where the copy construction fails after destroying the object.
+//
+// In some cases, we can completely avoid the use of an empty state; we provide a specialization of
+// __movable_box that does this, see below for the details.
+
+// until C++23, `__movable_box` was named `__copyable_box` and required the stored type to be copy-constructible, not
+// just move-constructible; we preserve the old behavior in pre-C++23 modes.
+template <class _Tp>
+concept __movable_box_object =
+#  if _LIBCPP_STD_VER >= 23
+    move_constructible<_Tp>
+#  else
+    copy_constructible<_Tp>
+#  endif
+    && is_object_v<_Tp>;
+
+namespace ranges {
+// Primary template - uses std::optional and introduces an empty state in case assignment fails.
+template <__movable_box_object _Tp>
+class __movable_box {
+  _LIBCPP_NO_UNIQUE_ADDRESS optional<_Tp> __val_;
+
+public:
+  template <class... _Args>
+    requires is_constructible_v<_Tp, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __movable_box(in_place_t, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>)
+      : __val_(in_place, std::forward<_Args>(__args)...) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+    requires default_initializable<_Tp>
+      : __val_(in_place) {}
+
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box const&) = default;
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box&&)      = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box&
+  operator=(__movable_box const& __other) noexcept(is_nothrow_copy_constructible_v<_Tp>)
+#  if _LIBCPP_STD_VER >= 23
+    requires copy_constructible<_Tp>
+#  endif
+  {
+    if (this != std::addressof(__other)) {
+      if (__other.__has_value())
+        __val_.emplace(*__other);
+      else
+        __val_.reset();
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box&&)
+    requires movable<_Tp>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box&
+  operator=(__movable_box&& __other) noexcept(is_nothrow_move_constructible_v<_Tp>) {
+    if (this != std::addressof(__other)) {
+      if (__other.__has_value())
+        __val_.emplace(std::move(*__other));
+      else
+        __val_.reset();
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return *__val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return *__val_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept { return __val_.operator->(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept { return __val_.operator->(); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return __val_.has_value(); }
+};
+
+// This partial specialization implements an optimization for when we know we don't need to store
+// an empty state to represent failure to perform an assignment. For copy-assignment, this happens:
+//
+// 1. If the type is copyable (which includes copy-assignment), we can use the type's own assignment operator
+//    directly and avoid using std::optional.
+// 2. If the type is not copyable, but it is nothrow-copy-constructible, then we can implement assignment as
+//    destroy-and-then-construct and we know it will never fail, so we don't need an empty state.
+//
+// The exact same reasoning can be applied for move-assignment, with copyable replaced by movable and
+// nothrow-copy-constructible replaced by nothrow-move-constructible. This specialization is enabled
+// whenever we can apply any of these optimizations for both the copy assignment and the move assignment
+// operator.
+
+#  if _LIBCPP_STD_VER >= 23
+template <class _Tp>
+concept __doesnt_need_empty_state =
+    (copy_constructible<_Tp>
+         // 1. If copy_constructible<T> is true, movable-box<T> should store only a T if either T models
+         //    copyable, or is_nothrow_move_constructible_v<T> && is_nothrow_copy_constructible_v<T> is true.
+         ? copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Tp>)
+         // 2. Otherwise, movable-box<T> should store only a T if either T models movable or
+         //    is_nothrow_move_constructible_v<T> is true.
+         : movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
+#  else
+
+template <class _Tp>
+concept __doesnt_need_empty_state_for_copy = copyable<_Tp> || is_nothrow_copy_constructible_v<_Tp>;
+
+template <class _Tp>
+concept __doesnt_need_empty_state_for_move = movable<_Tp> || is_nothrow_move_constructible_v<_Tp>;
+
+template <class _Tp>
+concept __doesnt_need_empty_state = __doesnt_need_empty_state_for_copy<_Tp> && __doesnt_need_empty_state_for_move<_Tp>;
+#  endif
+
+template <__movable_box_object _Tp>
+  requires __doesnt_need_empty_state<_Tp>
+class __movable_box<_Tp> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
+
+public:
+  template <class... _Args>
+    requires is_constructible_v<_Tp, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __movable_box(in_place_t, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>)
+      : __val_(std::forward<_Args>(__args)...) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+    requires default_initializable<_Tp>
+      : __val_() {}
+
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box const&) = default;
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box&&)      = default;
+
+  // Implementation of assignment operators in case we perform optimization (1)
+  _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box const&)
+    requires copyable<_Tp>
+  = default;
+  _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box&&)
+    requires movable<_Tp>
+  = default;
+
+  // Implementation of assignment operators in case we perform optimization (2)
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box& operator=(__movable_box const& __other) noexcept {
+    static_assert(is_nothrow_copy_constructible_v<_Tp>);
+    if (this != std::addressof(__other)) {
+      std::destroy_at(std::addressof(__val_));
+      std::construct_at(std::addressof(__val_), __other.__val_);
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box& operator=(__movable_box&& __other) noexcept {
+    static_assert(is_nothrow_move_constructible_v<_Tp>);
+    if (this != std::addressof(__other)) {
+      std::destroy_at(std::addressof(__val_));
+      std::construct_at(std::addressof(__val_), std::move(__other.__val_));
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return __val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return __val_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept { return std::addressof(__val_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept { return std::addressof(__val_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
+};
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_MOVABLE_BOX_H

libcxx/include/__ranges/single_view.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANGES_SINGLE_VIEW_H
 #define _LIBCPP___RANGES_SINGLE_VIEW_H
 
 #include <__concepts/constructible.h>
 #include <__config>
-#include <__ranges/copyable_box.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_object.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<copy_constructible _Tp>
-    requires is_object_v<_Tp>
-  class single_view : public view_interface<single_view<_Tp>> {
-    __copyable_box<_Tp> __value_;
+#  if _LIBCPP_STD_VER >= 23
+template <move_constructible _Tp>
+#  else
+template <copy_constructible _Tp>
+#  endif
+  __movable_box<_Tp> __value_;
 
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    single_view() requires default_initializable<_Tp> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(const _Tp& __t) : __value_(in_place, __t) {}
+  _LIBCPP_HIDE_FROM_ABI single_view()
+    requires default_initializable<_Tp>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(const _Tp& __t)
+#  if _LIBCPP_STD_VER >= 23
+    requires copy_constructible<_Tp>
+#  endif
+      : __value_(in_place, __t) {
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(_Tp&& __t) : __value_(in_place, std::move(__t)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(_Tp&& __t) : __value_(in_place, std::move(__t)) {}
 
-    template<class... _Args>
-      requires constructible_from<_Tp, _Args...>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(in_place_t, _Args&&... __args)
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(in_place_t, _Args&&... __args)
       : __value_{in_place, std::forward<_Args>(__args)...} {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp* begin() noexcept { return data(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* begin() noexcept { return data(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const _Tp* begin() const noexcept { return data(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* begin() const noexcept { return data(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp* end() noexcept { return data() + 1; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* end() noexcept { return data() + 1; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const _Tp* end() const noexcept { return data() + 1; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* end() const noexcept { return data() + 1; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr size_t size() noexcept { return 1; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 1; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp* data() noexcept { return __value_.operator->(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* data() noexcept { return __value_.operator->(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
-  };
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
 
 template<class _Tp>
 single_view(_Tp) -> single_view<_Tp>;
 
 namespace views {
 namespace __single_view {
 
 struct __fn : __range_adaptor_closure<__fn> {

libcxx/include/__ranges/take_while_view.h

 #include <__config>
 #include <__functional/bind_back.h>
 #include <__functional/invoke.h>
 #include <__iterator/concepts.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_object.h>
 #include <__type_traits/maybe_const.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>

 
 template <view _View, class _Pred>
   requires input_range<_View> && is_object_v<_Pred> && indirect_unary_predicate<const _Pred, iterator_t<_View>>
 class take_while_view : public view_interface<take_while_view<_View, _Pred>> {
   template <bool>
   class __sentinel;
 
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI take_while_view()
     requires default_initializable<_View> && default_initializable<_Pred>
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 take_while_view(_View __base, _Pred __pred)
       : __base_(std::move(__base)), __pred_(std::in_place, std::move(__pred)) {}

libcxx/include/__ranges/transform_view.h

 #include <__functional/bind_back.h>
 #include <__functional/invoke.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
 #include <__ranges/empty.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_object.h>
 #include <__type_traits/is_reference.h>
concept __regular_invocable_with_range_ref =
   regular_invocable<_Fn, range_reference_t<_View>>;
 
 template<class _View, class _Fn>
 concept __transform_view_constraints =
   view<_View> && is_object_v<_Fn> &&
   regular_invocable<_Fn&, range_reference_t<_View>> &&
   __can_reference<invoke_result_t<_Fn&, range_reference_t<_View>>>;
 
-template<input_range _View, copy_constructible _Fn>
+#  if _LIBCPP_STD_VER >= 23
+template <input_range _View, move_constructible _Fn>
+#  else
+template <input_range _View, copy_constructible _Fn>
+#  endif
   requires __transform_view_constraints<_View, _Fn>
 class transform_view : public view_interface<transform_view<_View, _Fn>> {
   template<bool> class __iterator;
   template<bool> class __sentinel;
 
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Fn> __func_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Fn> __func_;
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   transform_view()
     requires default_initializable<_View> && default_initializable<_Fn> = default;
 
   _LIBCPP_HIDE_FROM_ABI
conditional_t<
       derived_from<_Cat, contiguous_iterator_tag>,
       random_access_iterator_tag,
       _Cat
     >,
     input_iterator_tag
   >;
 };
 
-template<input_range _View, copy_constructible _Fn>
+#  if _LIBCPP_STD_VER >= 23
+template <input_range _View, move_constructible _Fn>
+#  else
+template <input_range _View, copy_constructible _Fn>
+#  endif
   requires __transform_view_constraints<_View, _Fn>
-template<bool _Const>
-class transform_view<_View, _Fn>::__iterator
-  : public __transform_view_iterator_category_base<_View, _Fn> {
+template <bool _Const>
+class transform_view<_View, _Fn>::__iterator : public __transform_view_iterator_category_base<_View, _Fn> {
 
   using _Parent = __maybe_const<_Const, transform_view>;
   using _Base = __maybe_const<_Const, _View>;
 
   _Parent *__parent_ = nullptr;
 
   template<bool>
   friend class transform_view<_View, _Fn>::__iterator;
public:
   {
     if constexpr (is_lvalue_reference_v<decltype(*__i)>)
       return std::move(*__i);
     else
       return *__i;
   }
 };
 
-template<input_range _View, copy_constructible _Fn>
+#  if _LIBCPP_STD_VER >= 23
+template <input_range _View, move_constructible _Fn>
+#  else
+template <input_range _View, copy_constructible _Fn>
+#  endif
   requires __transform_view_constraints<_View, _Fn>
-template<bool _Const>
+template <bool _Const>
 class transform_view<_View, _Fn>::__sentinel {
   using _Parent = __maybe_const<_Const, transform_view>;
   using _Base = __maybe_const<_Const, _View>;
 
   sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 
   template<bool>
   friend class transform_view<_View, _Fn>::__iterator;

libcxx/include/module.modulemap.in

module __ranges {
         private header "__ranges/all.h"
         export functional.__functional.compose
         export functional.__functional.perfect_forward
       }
       module as_rvalue_view             { private header "__ranges/as_rvalue_view.h" }
       module common_view                { private header "__ranges/common_view.h" }
       module concepts                   { private header "__ranges/concepts.h" }
       module container_compatible_range { private header "__ranges/container_compatible_range.h" }
-      module copyable_box               { private header "__ranges/copyable_box.h" }
       module counted                    {
         private header "__ranges/counted.h"
         export span
       }
       module dangling                   { private header "__ranges/dangling.h" }
       module data                       { private header "__ranges/data.h" }
       module drop_view                  { private header "__ranges/drop_view.h" }
       module drop_while_view            { private header "__ranges/drop_while_view.h" }
       module elements_view              { private header "__ranges/elements_view.h" }
       module empty                      { private header "__ranges/empty.h" }
       module empty_view                 { private header "__ranges/empty_view.h" }
       module enable_borrowed_range      { private header "__ranges/enable_borrowed_range.h" }
       module enable_view                { private header "__ranges/enable_view.h" }
       module filter_view                { private header "__ranges/filter_view.h" }
       module from_range                 { private header "__ranges/from_range.h" }
       module iota_view                  { private header "__ranges/iota_view.h" }
       module istream_view               {
         @requires_LIBCXX_ENABLE_LOCALIZATION@
         private header "__ranges/istream_view.h"
       }
       module join_view                  { private header "__ranges/join_view.h" }
       module lazy_split_view            { private header "__ranges/lazy_split_view.h" }
+      module movable_box                { private header "__ranges/movable_box.h" }
       module non_propagating_cache      { private header "__ranges/non_propagating_cache.h" }
       module owning_view                { private header "__ranges/owning_view.h" }
       module range_adaptor              { private header "__ranges/range_adaptor.h" }
       module rbegin                     { private header "__ranges/rbegin.h" }
       module ref_view                   { private header "__ranges/ref_view.h" }
       module rend                       { private header "__ranges/rend.h" }
       module reverse_view               { private header "__ranges/reverse_view.h" }
       module single_view                { private header "__ranges/single_view.h" }

libcxx/include/version

 __cpp_lib_not_fn                                        201603L <functional>
 __cpp_lib_null_iterators                                201304L <iterator>
 __cpp_lib_optional                                      202110L <optional>
                                                         201606L // C++17
 __cpp_lib_out_ptr                                       202106L <memory>
 __cpp_lib_parallel_algorithm                            201603L <algorithm> <numeric>
 __cpp_lib_polymorphic_allocator                         201902L <memory_resource>
 __cpp_lib_quoted_string_io                              201304L <iomanip>
-__cpp_lib_ranges                                        202106L <algorithm> <functional> <iterator>
+__cpp_lib_ranges                                        202207L <algorithm> <functional> <iterator>
                                                                 <memory> <ranges>
 __cpp_lib_ranges_as_rvalue                              202207L <ranges>
 __cpp_lib_ranges_chunk                                  202202L <ranges>
 __cpp_lib_ranges_chunk_by                               202202L <ranges>
 __cpp_lib_ranges_iota                                   202202L <numeric>
 __cpp_lib_ranges_join_with                              202202L <ranges>
 __cpp_lib_ranges_slide                                  202202L <ranges>
 __cpp_lib_ranges_starts_ends_with                       202106L <algorithm>

 #   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
 # if !defined(_LIBCPP_AVAILABILITY_HAS_NO_PMR)
 #   define __cpp_lib_polymorphic_allocator              201902L
 # endif
-# define __cpp_lib_ranges                               202106L
+# define __cpp_lib_ranges                               202207L
 # define __cpp_lib_remove_cvref                         201711L
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # undef  __cpp_lib_shared_ptr_arrays
 # define __cpp_lib_shared_ptr_arrays                    201707L
 # define __cpp_lib_shift                                201806L
 // # define __cpp_lib_smart_ptr_for_overwrite              202002L

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/properties.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
-
-// Test various properties of <copyable-box>
-
-#include <ranges>
-
-#include <optional>
-
-#include "types.h"
-
-template <class T>
-constexpr bool valid_copyable_box = requires {
-  typename std::ranges::__copyable_box<T>;
-};
-
-struct NotCopyConstructible {
-  NotCopyConstructible() = default;
-  NotCopyConstructible(NotCopyConstructible&&) = default;
-  NotCopyConstructible(NotCopyConstructible const&) = delete;
-  NotCopyConstructible& operator=(NotCopyConstructible&&) = default;
-  NotCopyConstructible& operator=(NotCopyConstructible const&) = default;
-};
-
-static_assert(!valid_copyable_box<void>); // not an object type
-static_assert(!valid_copyable_box<int&>); // not an object type
-static_assert(!valid_copyable_box<NotCopyConstructible>);
-
-// primary template
-static_assert(sizeof(std::ranges::__copyable_box<CopyConstructible>) == sizeof(std::optional<CopyConstructible>));
-
-// optimization #1
-static_assert(sizeof(std::ranges::__copyable_box<Copyable>) == sizeof(Copyable));
-static_assert(alignof(std::ranges::__copyable_box<Copyable>) == alignof(Copyable));
-
-// optimization #2
-static_assert(sizeof(std::ranges::__copyable_box<NothrowCopyConstructible>) == sizeof(NothrowCopyConstructible));
-static_assert(alignof(std::ranges::__copyable_box<NothrowCopyConstructible>) == alignof(NothrowCopyConstructible));

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // T* <copyable-box>::operator->()
 // const T* <copyable-box>::operator->() const
 
 #include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
-template<class T>
+template <class T>
 constexpr void check() {
   // non-const version
   {
-    std::ranges::__copyable_box<T> x(std::in_place, 10);
+    std::ranges::__movable_box<T> x(std::in_place, 10);
     T* result = x.operator->();
     static_assert(noexcept(x.operator->()));
     assert(result->value == 10);
     assert(x->value == 10);
   }
 
   // const version
   {
-    std::ranges::__copyable_box<T> const x(std::in_place, 10);
+    std::ranges::__movable_box<T> const x(std::in_place, 10);
     const T* result = x.operator->();
     static_assert(noexcept(x.operator->()));
     assert(result->value == 10);
     assert(x->value == 10);
   }
 }
 
 constexpr bool test() {
-  check<CopyConstructible>(); // primary template
-  check<Copyable>(); // optimization #1
+  check<CopyConstructible>();        // primary template
+  check<Copyable>();                 // optimization #1
   check<NothrowCopyConstructible>(); // optimization #2
   return true;
 }
 
 int main(int, char**) {
   assert(test());
   static_assert(test());
   return 0;
 }

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/assign.copy.pass.cpp

 #include <utility> // in_place_t
 
 #include "test_macros.h"
 #include "types.h"
 
 constexpr bool test() {
   // Test the primary template
   {
-    using Box = std::ranges::__copyable_box<CopyConstructible>;
-    static_assert( std::is_copy_assignable_v<Box>);
+    using Box = std::ranges::__movable_box<CopyConstructible>;
+    static_assert(std::is_copy_assignable_v<Box>);
     static_assert(!std::is_nothrow_copy_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box const y(std::in_place, 10);
       Box& result = (x = y);
 
       assert(&result == &x);
// check self-assignment
       assert(&result == &x);
       assert(x.__has_value());
       assert((*x).value == 5);
     }
   }
 
   // Test optimization #1 for copy-assignment
   {
-    using Box = std::ranges::__copyable_box<Copyable>;
-    static_assert( std::is_copy_assignable_v<Box>);
+    using Box = std::ranges::__movable_box<Copyable>;
+    static_assert(std::is_copy_assignable_v<Box>);
     static_assert(!std::is_nothrow_copy_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box const y(std::in_place, 10);
       Box& result = (x = y);
 
       assert(&result == &x);
// check self-assignment (should use the underlying type's assignment too)
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_copy_assign);
     }
   }
 
   // Test optimization #2 for copy-assignment
   {
-    using Box = std::ranges::__copyable_box<NothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<NothrowCopyConstructible>;
     static_assert(std::is_copy_assignable_v<Box>);
     static_assert(std::is_nothrow_copy_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box const y(std::in_place, 10);
       Box& result = (x = y);
 
constexpr bool test() {
 
   return true;
 }
 
 // Tests for the empty state. Those can't be constexpr, since they are only reached
 // through throwing an exception.
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
 void test_empty_state() {
-  using Box = std::ranges::__copyable_box<ThrowsOnCopy>;
+  using Box = std::ranges::__movable_box<ThrowsOnCopy>;
 
   // assign non-empty to empty
   {
     Box x = create_empty_box();
     Box const y(std::in_place, 10);
     Box& result = (x = y);
 
     assert(&result == &x);
     assert(x.__has_value());
     assert(y.__has_value());
     assert((*x).value == 10);
   }
   // assign empty to non-empty
   {
     Box x(std::in_place, 5);
     Box const y = create_empty_box();
     Box& result = (x = y);
 
     assert(&result == &x);
     assert(!x.__has_value());
     assert(!y.__has_value());
   }
   // assign empty to empty
   {
-    Box x = create_empty_box();
+    Box x       = create_empty_box();
     Box const y = create_empty_box();
     Box& result = (x = y);
 
     assert(&result == &x);
     assert(!x.__has_value());
     assert(!y.__has_value());
   }
   // check self-assignment in empty case
   {
-    Box x = create_empty_box();
+    Box x       = create_empty_box();
     Box& result = (x = x);
 
     assert(&result == &x);
     assert(!x.__has_value());
   }
 }
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
 

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/assign.move.pass.cpp

 #include <utility> // in_place_t
 
 #include "test_macros.h"
 #include "types.h"
 
 constexpr bool test() {
   // Test the primary template
   {
-    using Box = std::ranges::__copyable_box<CopyConstructible>;
-    static_assert( std::is_move_assignable_v<Box>);
+    using Box = std::ranges::__movable_box<CopyConstructible>;
+    static_assert(std::is_move_assignable_v<Box>);
     static_assert(!std::is_nothrow_move_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
       assert(&result == &x);
// check self-assignment
       assert(&result == &x);
       assert(x.__has_value());
       assert((*x).value == 5);
     }
   }
 
   // Make sure that we use the native move assignment in the primary template if we can.
   {
-    using Box = std::ranges::__copyable_box<CopyConstructibleMovable>;
+    using Box = std::ranges::__movable_box<CopyConstructibleMovable>;
     static_assert(std::is_move_assignable_v<Box>);
-    static_assert(std::is_nothrow_move_assignable_v<Box> == std::is_nothrow_move_assignable_v<CopyConstructibleMovable>);
+    static_assert(
+        std::is_nothrow_move_assignable_v<Box> == std::is_nothrow_move_assignable_v<CopyConstructibleMovable>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
       assert(&result == &x);
       assert(x.__has_value());
// check self-assignment
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_move_assign);
     }
   }
 
   // Test optimization #1 for move assignment
   {
-    using Box = std::ranges::__copyable_box<Copyable>;
-    static_assert( std::is_move_assignable_v<Box>);
+    using Box = std::ranges::__movable_box<Copyable>;
+    static_assert(std::is_move_assignable_v<Box>);
     static_assert(!std::is_nothrow_move_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
       assert(&result == &x);
// check self-assignment (should use the underlying type's assignment too)
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_move_assign);
     }
   }
 
   // Test optimization #1 for move assignment with a type that uses optimization #2 for copy assignment
   {
-    using Box = std::ranges::__copyable_box<MovableNothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<MovableNothrowCopyConstructible>;
     static_assert(std::is_move_assignable_v<Box>);
-    static_assert(std::is_nothrow_move_assignable_v<Box> == std::is_nothrow_move_assignable_v<MovableNothrowCopyConstructible>);
+    static_assert(
+        std::is_nothrow_move_assignable_v<Box> == std::is_nothrow_move_assignable_v<MovableNothrowCopyConstructible>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
       assert(&result == &x);
       assert(x.__has_value());
// check self-assignment (should use the underlying type's assignment too)
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_move_assign);
     }
   }
 
   // Test optimization #2 for move assignment
   {
-    using Box = std::ranges::__copyable_box<NothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<NothrowCopyConstructible>;
     static_assert(std::is_move_assignable_v<Box>);
     static_assert(std::is_nothrow_move_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
constexpr bool test() {
 
   return true;
 }
 
 // Tests for the empty state. Those can't be constexpr, since they are only reached
 // through throwing an exception.
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
 void test_empty_state() {
-  using Box = std::ranges::__copyable_box<ThrowsOnCopy>;
+  using Box = std::ranges::__movable_box<ThrowsOnCopy>;
 
   // assign non-empty to empty
   {
     Box x = create_empty_box();
     Box y(std::in_place, 10);
     Box& result = (x = std::move(y));
 
     assert(&result == &x);
     assert(x.__has_value());
     assert(y.__has_value());
     assert((*x).value == 10);
   }
   // assign empty to non-empty
   {
     Box x(std::in_place, 5);
-    Box y = create_empty_box();
+    Box y       = create_empty_box();
     Box& result = (x = std::move(y));
 
     assert(&result == &x);
     assert(!x.__has_value());
     assert(!y.__has_value());
   }
   // assign empty to empty
   {
-    Box x = create_empty_box();
-    Box y = create_empty_box();
+    Box x       = create_empty_box();
+    Box y       = create_empty_box();
     Box& result = (x = std::move(y));
 
     assert(&result == &x);
     assert(!x.__has_value());
     assert(!y.__has_value());
   }
   // check self-assignment in empty case
   {
-    Box x = create_empty_box();
+    Box x       = create_empty_box();
     Box& result = (x = std::move(x));
 
     assert(&result == &x);
     assert(!x.__has_value());
   }
 }
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
 

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/ctor.default.pass.cpp

 #include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
-template<class T>
-using Box = std::ranges::__copyable_box<T>;
+template <class T>
+using Box = std::ranges::__movable_box<T>;
 
 struct NoDefault {
   NoDefault() = delete;
 };
 static_assert(!std::is_default_constructible_v<Box<NoDefault>>);
 
-template<bool Noexcept>
+template <bool Noexcept>
 struct DefaultNoexcept {
   DefaultNoexcept() noexcept(Noexcept);
 };
-static_assert( std::is_nothrow_default_constructible_v<Box<DefaultNoexcept<true>>>);
+static_assert(std::is_nothrow_default_constructible_v<Box<DefaultNoexcept<true>>>);
 static_assert(!std::is_nothrow_default_constructible_v<Box<DefaultNoexcept<false>>>);
 
 constexpr bool test() {
   // check primary template
   {
     Box<CopyConstructible> box;
     assert(box.__has_value());
     assert((*box).value == CopyConstructible().value);

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/ctor.in_place.pass.cpp

 #include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
-struct UnknownType { };
+struct UnknownType {};
 
-template<bool Noexcept>
+template <bool Noexcept>
 struct NothrowConstructible {
   explicit NothrowConstructible(int) noexcept(Noexcept);
 };
 
 constexpr bool test() {
   // Test the primary template
   {
-    using Box = std::ranges::__copyable_box<CopyConstructible>;
+    using Box = std::ranges::__movable_box<CopyConstructible>;
     Box x(std::in_place, 5);
     assert((*x).value == 5);
 
     static_assert(!std::is_constructible_v<Box, std::in_place_t, UnknownType>);
   }
 
   // Test optimization #1
   {
-    using Box = std::ranges::__copyable_box<Copyable>;
+    using Box = std::ranges::__movable_box<Copyable>;
     Box x(std::in_place, 5);
     assert((*x).value == 5);
 
     static_assert(!std::is_constructible_v<Box, std::in_place_t, UnknownType>);
   }
 
   // Test optimization #2
   {
-    using Box = std::ranges::__copyable_box<NothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<NothrowCopyConstructible>;
     Box x(std::in_place, 5);
     assert((*x).value == 5);
 
     static_assert(!std::is_constructible_v<Box, std::in_place_t, UnknownType>);
   }
 
-  static_assert( std::is_nothrow_constructible_v<std::ranges::__copyable_box<NothrowConstructible<true>>, std::in_place_t, int>);
-  static_assert(!std::is_nothrow_constructible_v<std::ranges::__copyable_box<NothrowConstructible<false>>, std::in_place_t, int>);
+  static_assert(
+      std::is_nothrow_constructible_v<std::ranges::__movable_box<NothrowConstructible<true>>, std::in_place_t, int>);
+  static_assert(
+      !std::is_nothrow_constructible_v<std::ranges::__movable_box<NothrowConstructible<false>>, std::in_place_t, int>);
 
   return true;
 }
 
 int main(int, char**) {
   assert(test());
   static_assert(test());
   return 0;
 }

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/deref.pass.cpp

 #include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
-template<class T>
+template <class T>
 constexpr void check() {
   // non-const version
   {
-    std::ranges::__copyable_box<T> x(std::in_place, 10);
+    std::ranges::__movable_box<T> x(std::in_place, 10);
     T& result = *x;
     static_assert(noexcept(*x));
     assert(result.value == 10);
   }
 
   // const version
   {
-    std::ranges::__copyable_box<T> const x(std::in_place, 10);
+    std::ranges::__movable_box<T> const x(std::in_place, 10);
     T const& result = *x;
     static_assert(noexcept(*x));
     assert(result.value == 10);
   }
 }
 
 constexpr bool test() {
-  check<CopyConstructible>(); // primary template
-  check<Copyable>(); // optimization #1
+  check<CopyConstructible>();        // primary template
+  check<Copyable>();                 // optimization #1
   check<NothrowCopyConstructible>(); // optimization #2
   return true;
 }
 
 int main(int, char**) {
   assert(test());
   static_assert(test());
   return 0;
 }

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/has_value.pass.cpp

 #include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
-template<class T>
+template <class T>
 constexpr void check() {
-  std::ranges::__copyable_box<T> const x(std::in_place, 10);
+  std::ranges::__movable_box<T> const x(std::in_place, 10);
   assert(x.__has_value());
 }
 
 constexpr bool test() {
-  check<CopyConstructible>(); // primary template
-  check<Copyable>(); // optimization #1
+  check<CopyConstructible>();        // primary template
+  check<Copyable>();                 // optimization #1
   check<NothrowCopyConstructible>(); // optimization #2
   return true;
 }
 
 int main(int, char**) {
   assert(test());
   static_assert(test());
 
   // Tests for the empty state. Those can't be constexpr, since they are only reached
   // through throwing an exception.
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
   {
-    std::ranges::__copyable_box<ThrowsOnCopy> x = create_empty_box();
+    std::ranges::__movable_box<ThrowsOnCopy> x = create_empty_box();
     assert(!x.__has_value());
   }
 #endif
 
   return 0;
 }

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/no_unique_address.pass.cpp

 // This test ensures that <copyable-box> behaves correctly when it holds an empty type.
 
 #include <ranges>
 
 #include <cassert>
 #include <utility>
 
 bool copied = false;
-bool moved = false;
+bool moved  = false;
 
 struct Empty {
-  Empty() noexcept { }
+  Empty() noexcept {}
   Empty(Empty const&) noexcept { copied = true; }
   Empty(Empty&&) noexcept { moved = true; }
   Empty& operator=(Empty const&) = delete;
-  Empty& operator=(Empty&&) = delete;
+  Empty& operator=(Empty&&)      = delete;
 };
 
-using Box = std::ranges::__copyable_box<Empty>;
+using Box = std::ranges::__movable_box<Empty>;
 
-struct Inherit : Box { };
+struct Inherit : Box {};
 
 struct Hold : Box {
   [[no_unique_address]] Inherit member;
 };
 
 int main(int, char**) {
   Hold box;
 
-  Box& base = static_cast<Box&>(box);
+  Box& base   = static_cast<Box&>(box);
   Box& member = static_cast<Box&>(box.member);
 
   // Despite [[no_unique_address]], the two objects have the same type so they
   // can't share the same address.
   assert(&base != &member);
 
   // Make sure that we do perform the copy-construction, which wouldn't be the
   // case if the two <copyable-box>s had the same address.
   base = member;
   assert(copied);
 
   base = std::move(member);
   assert(moved);
 
   return 0;
 }

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/properties.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
+
+// Test various properties of <copyable-box>
+
+#include <ranges>
+
+#include <optional>
+
+#include "MoveOnly.h"
+
+#include "types.h"
+
+template <class T>
+constexpr bool valid_movable_box = requires { typename std::ranges::__movable_box<T>; };
+
+struct NotCopyConstructible {
+  NotCopyConstructible()                                       = default;
+  NotCopyConstructible(NotCopyConstructible&&)                 = default;
+  NotCopyConstructible(NotCopyConstructible const&)            = delete;
+  NotCopyConstructible& operator=(NotCopyConstructible&&)      = default;
+  NotCopyConstructible& operator=(NotCopyConstructible const&) = default;
+};
+
+static_assert(!valid_movable_box<void>); // not an object type
+static_assert(!valid_movable_box<int&>); // not an object type
+
+#if _LIBCPP_STD_VER >= 23
+struct NotCopyConstructibleNotMoveConstructible {
+  NotCopyConstructibleNotMoveConstructible()                                                           = default;
+  NotCopyConstructibleNotMoveConstructible(NotCopyConstructibleNotMoveConstructible&&)                 = delete;
+  NotCopyConstructibleNotMoveConstructible(NotCopyConstructibleNotMoveConstructible const&)            = delete;
+  NotCopyConstructibleNotMoveConstructible& operator=(NotCopyConstructibleNotMoveConstructible&&)      = delete;
+  NotCopyConstructibleNotMoveConstructible& operator=(NotCopyConstructibleNotMoveConstructible const&) = delete;
+};
+
+// [P2494R2] Relaxing range adaptors to allow for move only types.
+static_assert(!valid_movable_box<NotCopyConstructibleNotMoveConstructible>);
+static_assert(valid_movable_box<NotCopyConstructible>);
+static_assert(valid_movable_box<MoveOnly>);
+#else
+static_assert(!valid_movable_box<NotCopyConstructible>);
+#endif
+
+// primary template
+static_assert(sizeof(std::ranges::__movable_box<CopyConstructible>) == sizeof(std::optional<CopyConstructible>));
+
+// optimization #1
+static_assert(sizeof(std::ranges::__movable_box<Copyable>) == sizeof(Copyable));
+static_assert(alignof(std::ranges::__movable_box<Copyable>) == alignof(Copyable));
+
+// optimization #2
+static_assert(sizeof(std::ranges::__movable_box<NothrowCopyConstructible>) == sizeof(NothrowCopyConstructible));
+static_assert(alignof(std::ranges::__movable_box<NothrowCopyConstructible>) == alignof(NothrowCopyConstructible));

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/types.h

 
 #include <ranges>
 #include <cassert>
 #include <concepts>
 #include <type_traits>
 
 #include "test_macros.h"
 
-// NOTE: These types are strongly tied to the implementation of __copyable_box. See the documentation
-//       in __copyable_box for the meaning of optimizations #1 and #2.
+// NOTE: These types are strongly tied to the implementation of __movable_box. See the documentation
+//       in __movable_box for the meaning of optimizations #1 and #2.
 
 // Copy constructible, but neither copyable nor nothrow_copy/move_constructible. This uses the primary template.
 struct CopyConstructible {
   constexpr CopyConstructible() = default;
-  constexpr explicit CopyConstructible(int x) : value(x) { }
+  constexpr explicit CopyConstructible(int x) : value(x) {}
   CopyConstructible(CopyConstructible const&) noexcept(false) = default;
-  CopyConstructible& operator=(CopyConstructible const&) = delete;
+  CopyConstructible& operator=(CopyConstructible const&)      = delete;
 
   int value = -1;
 };
 static_assert(!std::copyable<CopyConstructible>);
 static_assert(!std::is_nothrow_copy_constructible_v<CopyConstructible>);
 static_assert(!std::movable<CopyConstructible>);
 static_assert(!std::is_nothrow_move_constructible_v<CopyConstructible>);
 
-
 // Copy constructible and movable, but not copyable. This uses the primary template, however we're
 // still able to use the native move-assignment operator in this case.
 struct CopyConstructibleMovable {
   constexpr CopyConstructibleMovable() = default;
-  constexpr explicit CopyConstructibleMovable(int x) : value(x) { }
+  constexpr explicit CopyConstructibleMovable(int x) : value(x) {}
   CopyConstructibleMovable(CopyConstructibleMovable const&) noexcept(false) = default;
-  CopyConstructibleMovable(CopyConstructibleMovable&&) noexcept(false) = default;
-  CopyConstructibleMovable& operator=(CopyConstructibleMovable const&) = delete;
+  CopyConstructibleMovable(CopyConstructibleMovable&&) noexcept(false)      = default;
+  CopyConstructibleMovable& operator=(CopyConstructibleMovable const&)      = delete;
 
   constexpr CopyConstructibleMovable& operator=(CopyConstructibleMovable&& other) {
-    value = other.value;
+    value           = other.value;
     did_move_assign = true;
     return *this;
   }
 
-  int value = -1;
+  int value            = -1;
   bool did_move_assign = false;
 };
 
-
 // Copyable type that is not nothrow_copy/move_constructible.
 // This triggers optimization #1 for the copy assignment and the move assignment.
 struct Copyable {
   constexpr Copyable() = default;
-  constexpr explicit Copyable(int x) : value(x) { }
+  constexpr explicit Copyable(int x) : value(x) {}
   Copyable(Copyable const&) noexcept(false) = default;
 
   constexpr Copyable& operator=(Copyable const& other) noexcept(false) {
-    value = other.value;
+    value           = other.value;
     did_copy_assign = true;
     return *this;
   }
 
   constexpr Copyable& operator=(Copyable&& other) noexcept(false) {
-    value = other.value;
+    value           = other.value;
     did_move_assign = true;
     return *this;
   }
 
-  int value = -1;
+  int value            = -1;
   bool did_copy_assign = false;
   bool did_move_assign = false;
 };
-static_assert( std::copyable<Copyable>);
+static_assert(std::copyable<Copyable>);
 static_assert(!std::is_nothrow_copy_constructible_v<Copyable>);
-static_assert( std::movable<Copyable>);
+static_assert(std::movable<Copyable>);
 static_assert(!std::is_nothrow_move_constructible_v<Copyable>);
 
-
 // Non-copyable type that is nothrow_copy_constructible and nothrow_move_constructible.
 // This triggers optimization #2 for the copy assignment and the move assignment.
 struct NothrowCopyConstructible {
   constexpr NothrowCopyConstructible() = default;
-  constexpr explicit NothrowCopyConstructible(int x) : value(x) { }
-  NothrowCopyConstructible(NothrowCopyConstructible const&) noexcept = default;
-  NothrowCopyConstructible(NothrowCopyConstructible&&) noexcept = default;
+  constexpr explicit NothrowCopyConstructible(int x) : value(x) {}
+  NothrowCopyConstructible(NothrowCopyConstructible const&) noexcept   = default;
+  NothrowCopyConstructible(NothrowCopyConstructible&&) noexcept        = default;
   NothrowCopyConstructible& operator=(NothrowCopyConstructible const&) = delete;
 
   int value = -1;
 };
 static_assert(!std::copyable<NothrowCopyConstructible>);
-static_assert( std::is_nothrow_copy_constructible_v<NothrowCopyConstructible>);
+static_assert(std::is_nothrow_copy_constructible_v<NothrowCopyConstructible>);
 static_assert(!std::movable<NothrowCopyConstructible>);
-static_assert( std::is_nothrow_move_constructible_v<NothrowCopyConstructible>);
+static_assert(std::is_nothrow_move_constructible_v<NothrowCopyConstructible>);
 
-
 // Non-copyable type that is nothrow_copy_constructible, and that is movable but NOT nothrow_move_constructible.
 // This triggers optimization #2 for the copy assignment, and optimization #1 for the move assignment.
 struct MovableNothrowCopyConstructible {
   constexpr MovableNothrowCopyConstructible() = default;
-  constexpr explicit MovableNothrowCopyConstructible(int x) : value(x) { }
-  MovableNothrowCopyConstructible(MovableNothrowCopyConstructible const&) noexcept = default;
+  constexpr explicit MovableNothrowCopyConstructible(int x) : value(x) {}
+  MovableNothrowCopyConstructible(MovableNothrowCopyConstructible const&) noexcept   = default;
   MovableNothrowCopyConstructible(MovableNothrowCopyConstructible&&) noexcept(false) = default;
   constexpr MovableNothrowCopyConstructible& operator=(MovableNothrowCopyConstructible&& other) {
-    value = other.value;
+    value           = other.value;
     did_move_assign = true;
     return *this;
   }
 
-  int value = -1;
+  int value            = -1;
   bool did_move_assign = false;
 };
 static_assert(!std::copyable<MovableNothrowCopyConstructible>);
-static_assert( std::is_nothrow_copy_constructible_v<MovableNothrowCopyConstructible>);
-static_assert( std::movable<MovableNothrowCopyConstructible>);
+static_assert(std::is_nothrow_copy_constructible_v<MovableNothrowCopyConstructible>);
+static_assert(std::movable<MovableNothrowCopyConstructible>);
 static_assert(!std::is_nothrow_move_constructible_v<MovableNothrowCopyConstructible>);
 
-
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
 // A type that we can make throw when copied from. This is used to create a
 // copyable-box in the empty state.
 static constexpr int THROW_WHEN_COPIED_FROM = 999;
 struct ThrowsOnCopy {
   constexpr ThrowsOnCopy() = default;
-  constexpr explicit ThrowsOnCopy(int x) : value(x) { }
+  constexpr explicit ThrowsOnCopy(int x) : value(x) {}
   ThrowsOnCopy(ThrowsOnCopy const& other) {
-    if (other.value == THROW_WHEN_COPIED_FROM) throw 0;
-    else                                       value = other.value;
+    if (other.value == THROW_WHEN_COPIED_FROM)
+      throw 0;
+    else
+      value = other.value;
   }
 
   ThrowsOnCopy& operator=(ThrowsOnCopy const&) = delete; // prevent from being copyable
 
   int value = -1;
 };
 
 // Creates an empty box. The only way to do that is to try assigning one box
 // to another and have that fail due to an exception when calling the copy
 // constructor. The assigned-to box will then be in the empty state.
-inline std::ranges::__copyable_box<ThrowsOnCopy> create_empty_box() {
-  std::ranges::__copyable_box<ThrowsOnCopy> box1;
-  std::ranges::__copyable_box<ThrowsOnCopy> box2(std::in_place, THROW_WHEN_COPIED_FROM);
+inline std::ranges::__movable_box<ThrowsOnCopy> create_empty_box() {
+  std::ranges::__movable_box<ThrowsOnCopy> box1;
+  std::ranges::__movable_box<ThrowsOnCopy> box2(std::in_place, THROW_WHEN_COPIED_FROM);
   try {
     box1 = box2; // throws during assignment, which is implemented as a call to the copy ctor
   } catch (...) {
     // now, box1 is empty
     assert(!box1.__has_value());
     return box1;
   }
   assert(false && "should never be reached");
   return box1; // to silence warning about missing return in non-void function
 }
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
 
 #endif // TEST_LIBCXX_RANGES_RANGE_ADAPTORS_RANGE_COPY_WRAP_TYPES_H

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

 // <algorithm>
 
 // Test the feature test macros defined by <algorithm>
 
 /*  Constant                                 Value
     __cpp_lib_clamp                          201603L [C++17]
     __cpp_lib_constexpr_algorithms           201806L [C++20]
     __cpp_lib_parallel_algorithm             201603L [C++17]
-    __cpp_lib_ranges                         202106L [C++20]
+    __cpp_lib_ranges                         202207L [C++20]
     __cpp_lib_ranges_starts_ends_with        202106L [C++23]
     __cpp_lib_robust_nonmodifying_seq_ops    201304L [C++14]
     __cpp_lib_sample                         201603L [C++17]
     __cpp_lib_shift                          201806L [C++20]
 */
 
 #include <algorithm>
 #include "test_macros.h"

 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifdef __cpp_lib_ranges_starts_ends_with
 #   error "__cpp_lib_ranges_starts_ends_with should not be defined before c++23"
 # endif
 
 # ifndef __cpp_lib_robust_nonmodifying_seq_ops
 #   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++20"

 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_starts_ends_with
 #     error "__cpp_lib_ranges_starts_ends_with should be defined in c++23"
 #   endif
 #   if __cpp_lib_ranges_starts_ends_with != 202106L
 #     error "__cpp_lib_ranges_starts_ends_with should have the value 202106L in c++23"

 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_starts_ends_with
 #     error "__cpp_lib_ranges_starts_ends_with should be defined in c++26"
 #   endif
 #   if __cpp_lib_ranges_starts_ends_with != 202106L
 #     error "__cpp_lib_ranges_starts_ends_with should have the value 202106L in c++26"

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

/*  Constant                           Value
     __cpp_lib_boyer_moore_searcher     201603L [C++17]
     __cpp_lib_constexpr_functional     201907L [C++20]
     __cpp_lib_copyable_function        202306L [C++26]
     __cpp_lib_function_ref             202306L [C++26]
     __cpp_lib_invoke                   201411L [C++17]
     __cpp_lib_invoke_r                 202106L [C++23]
     __cpp_lib_move_only_function       202110L [C++23]
     __cpp_lib_not_fn                   201603L [C++17]
-    __cpp_lib_ranges                   202106L [C++20]
+    __cpp_lib_ranges                   202207L [C++20]
     __cpp_lib_result_of_sfinae         201210L [C++14]
     __cpp_lib_transparent_operators    201210L [C++14]
                                        201510L [C++17]
     __cpp_lib_unwrap_ref               201811L [C++20]
 */
 
 #include <functional>
 #include "test_macros.h"

 # endif
 # if __cpp_lib_not_fn != 201603L
 #   error "__cpp_lib_not_fn should have the value 201603L in c++20"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifndef __cpp_lib_result_of_sfinae
 #   error "__cpp_lib_result_of_sfinae should be defined in c++20"
 # endif
 # if __cpp_lib_result_of_sfinae != 201210L
 #   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++20"
 # endif

 # endif
 # if __cpp_lib_not_fn != 201603L
 #   error "__cpp_lib_not_fn should have the value 201603L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_result_of_sfinae
 #   error "__cpp_lib_result_of_sfinae should be defined in c++23"
 # endif
 # if __cpp_lib_result_of_sfinae != 201210L
 #   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++23"
 # endif

 # endif
 # if __cpp_lib_not_fn != 201603L
 #   error "__cpp_lib_not_fn should have the value 201603L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_result_of_sfinae
 #   error "__cpp_lib_result_of_sfinae should be defined in c++26"
 # endif
 # if __cpp_lib_result_of_sfinae != 201210L
 #   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++26"
 # endif

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

 /*  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_ranges                        202207L [C++20]
     __cpp_lib_ssize                         201902L [C++20]
 */
 
 #include <iterator>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 

 # endif
 # if __cpp_lib_null_iterators != 201304L
 #   error "__cpp_lib_null_iterators should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifndef __cpp_lib_ssize
 #   error "__cpp_lib_ssize should be defined in c++20"
 # endif
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++20"
 # endif

 # endif
 # if __cpp_lib_null_iterators != 201304L
 #   error "__cpp_lib_null_iterators should have the value 201304L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_ssize
 #   error "__cpp_lib_ssize should be defined in c++23"
 # endif
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++23"
 # endif

 # endif
 # if __cpp_lib_null_iterators != 201304L
 #   error "__cpp_lib_null_iterators should have the value 201304L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_ssize
 #   error "__cpp_lib_ssize should be defined in c++26"
 # endif
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++26"
 # endif
 
 #endif // TEST_STD_VER > 23
 

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

/*  Constant                                      Value
     __cpp_lib_assume_aligned                      201811L [C++20]
     __cpp_lib_atomic_value_initialization         201911L [C++20]
     __cpp_lib_constexpr_dynamic_alloc             201907L [C++20]
     __cpp_lib_constexpr_memory                    201811L [C++20]
                                                   202202L [C++23]
     __cpp_lib_enable_shared_from_this             201603L [C++17]
     __cpp_lib_make_unique                         201304L [C++14]
     __cpp_lib_out_ptr                             202106L [C++23]
-    __cpp_lib_ranges                              202106L [C++20]
+    __cpp_lib_ranges                              202207L [C++20]
     __cpp_lib_raw_memory_algorithms               201606L [C++17]
     __cpp_lib_shared_ptr_arrays                   201611L [C++17]
                                                   201707L [C++20]
     __cpp_lib_shared_ptr_weak_type                201606L [C++17]
     __cpp_lib_smart_ptr_for_overwrite             202002L [C++20]
     __cpp_lib_smart_ptr_owner_equality            202306L [C++26]
     __cpp_lib_to_address                          201711L [C++20]
     __cpp_lib_transparent_operators               201210L [C++14]

 
 # ifdef __cpp_lib_out_ptr
 #   error "__cpp_lib_out_ptr should not be defined before c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifndef __cpp_lib_raw_memory_algorithms
 #   error "__cpp_lib_raw_memory_algorithms should be defined in c++20"
 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++20"
 # endif

 #   ifdef __cpp_lib_out_ptr
 #     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_raw_memory_algorithms
 #   error "__cpp_lib_raw_memory_algorithms should be defined in c++23"
 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++23"
 # endif

 #   ifdef __cpp_lib_out_ptr
 #     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_raw_memory_algorithms
 #   error "__cpp_lib_raw_memory_algorithms should be defined in c++26"
 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++26"
 # endif

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

 //
 // clang-format off
 
 // <ranges>
 
 // Test the feature test macros defined by <ranges>
 
 /*  Constant                      Value
-    __cpp_lib_ranges              202106L [C++20]
+    __cpp_lib_ranges              202207L [C++20]
     __cpp_lib_ranges_as_rvalue    202207L [C++23]
     __cpp_lib_ranges_chunk        202202L [C++23]
     __cpp_lib_ranges_chunk_by     202202L [C++23]
     __cpp_lib_ranges_join_with    202202L [C++23]
     __cpp_lib_ranges_slide        202202L [C++23]
     __cpp_lib_ranges_zip          202110L [C++23]
 */
 

 #   error "__cpp_lib_ranges_zip should not be defined before c++23"
 # endif
 
 #elif TEST_STD_VER == 20
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifdef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"

 #   error "__cpp_lib_ranges_zip should not be defined before c++23"
 # endif
 
 #elif TEST_STD_VER == 23
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++23"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++23"
 # endif

 #   endif
 # endif
 
 #elif TEST_STD_VER > 23
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++26"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++26"
 # endif

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

/*  Constant                                         Value
     __cpp_lib_not_fn                                 201603L [C++17]
     __cpp_lib_null_iterators                         201304L [C++14]
     __cpp_lib_optional                               201606L [C++17]
                                                      202110L [C++23]
     __cpp_lib_out_ptr                                202106L [C++23]
     __cpp_lib_parallel_algorithm                     201603L [C++17]
     __cpp_lib_polymorphic_allocator                  201902L [C++20]
     __cpp_lib_quoted_string_io                       201304L [C++14]
-    __cpp_lib_ranges                                 202106L [C++20]
+    __cpp_lib_ranges                                 202207L [C++20]
     __cpp_lib_ranges_as_rvalue                       202207L [C++23]
     __cpp_lib_ranges_chunk                           202202L [C++23]
     __cpp_lib_ranges_chunk_by                        202202L [C++23]
     __cpp_lib_ranges_iota                            202202L [C++23]
     __cpp_lib_ranges_join_with                       202202L [C++23]
     __cpp_lib_ranges_slide                           202202L [C++23]
     __cpp_lib_ranges_starts_ends_with                202106L [C++23]
     __cpp_lib_ranges_to_container                    202202L [C++23]

 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifdef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"

 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++23"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++23"
 # endif

 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++26"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++26"
 # endif

libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp

 #include <cctype>
 #include <functional>
 #include <list>
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include <cassert>
+#include "MoveOnly.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "types.h"
 
 template<class T, class F>
 concept ValidTransformView = requires { typename std::ranges::transform_view<T, F>; };
 
 struct BadFunction { };

 template<class E1, class E2, std::size_t N, class Join = std::plus<E1>>
 auto joinArrays(E1 (&a)[N], E2 (&b)[N], Join join = Join()) {
   return std::ranges::transform_view(a, [&a, &b, join](auto& x) {
     auto idx = (&x) - a;
     return join(x, b[idx]);
   });
 }
 
+#if _LIBCPP_STD_VER >= 23
+struct MoveOnlyFunction : public MoveOnly {
+  template <class T>
+  constexpr T operator()(T x) const {
+    return x + 42;
+  }
+};
+#endif
+
 struct NonConstView : std::ranges::view_base {
   explicit NonConstView(int *b, int *e) : b_(b), e_(e) {}
   const int *begin() { return b_; }  // deliberately non-const
   const int *end() { return e_; }    // deliberately non-const
   const int *b_;
   const int *e_;
 };
 
int main(int, char**) {
   }
 
   {
     std::string_view str = "Hello, World.";
     auto upp = toUpper(str);
     std::string_view check = "HELLO, WORLD.";
     assert(std::equal(upp.begin(), upp.end(), check.begin(), check.end()));
   }
+#if _LIBCPP_STD_VER >= 23
+  // [P2494R2] Relaxing range adaptors to allow for move only types.
+  // Test transform_view is valid when the function object is a move only type.
+  {
+    int a[]          = {1, 2, 3, 4};
+    auto transformed = NonConstView(a, a + 4) | std::views::transform(MoveOnlyFunction());
+    int expected[]   = {43, 44, 45, 46};
+    assert(std::equal(transformed.begin(), transformed.end(), expected, expected + 4));
+  }
+#endif
 
   return 0;
 }

libcxx/test/std/ranges/range.factories/range.single.view/cpo.pass.cpp

 
 #include <cassert>
 #include <concepts>
 #include <utility>
 #include "MoveOnly.h"
 
 // Can't invoke without arguments.
 static_assert(!std::is_invocable_v<decltype((std::views::single))>);
-// Can't invoke with a move-only type.
-static_assert(!std::is_invocable_v<decltype((std::views::single)), MoveOnly>);
-
+#if _LIBCPP_STD_VER >= 23
+// Can invoke with a move-only type.
+static_assert(std::is_invocable_v<decltype((std::views::single)), MoveOnly>);
+#endif
 constexpr bool test() {
   // Lvalue.
   {
     int x = 42;
     std::same_as<std::ranges::single_view<int>> decltype(auto) v = std::views::single(x);
     assert(v.size() == 1);
     assert(v.front() == x);
   }

libcxx/utils/data/ignore_format.txt

 libcxx/include/__random/uniform_random_bit_generator.h
 libcxx/include/__random/uniform_real_distribution.h
 libcxx/include/__random/weibull_distribution.h
 libcxx/include/ranges
 libcxx/include/__ranges/access.h
 libcxx/include/__ranges/all.h
 libcxx/include/__ranges/common_view.h
 libcxx/include/__ranges/concepts.h
-libcxx/include/__ranges/copyable_box.h
 libcxx/include/__ranges/counted.h
 libcxx/include/__ranges/data.h
 libcxx/include/__ranges/drop_view.h
 libcxx/include/__ranges/empty.h
 libcxx/include/__ranges/empty_view.h
 libcxx/include/__ranges/enable_view.h
 libcxx/include/__ranges/filter_view.h
 libcxx/include/__ranges/iota_view.h

libcxx/utils/generate_feature_test_macro_components.py

for x in [
         },
         {
             "name": "__cpp_lib_quoted_string_io",
             "values": {"c++14": 201304},
             "headers": ["iomanip"],
         },
         {
             "name": "__cpp_lib_ranges",
-            "values": {"c++20": 202106},
+            "values": {"c++20": 202207},
             "headers": ["algorithm", "functional", "iterator", "memory", "ranges"],
         },
         {
             "name": "__cpp_lib_ranges_as_rvalue",
             "values": {"c++23": 202207},
             "headers": ["ranges"],
         },
         {

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

sources = [
       "__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/container_compatible_range.h",
-      "__ranges/copyable_box.h",
+      "__ranges/movable_box.h",
       "__ranges/counted.h",
       "__ranges/dangling.h",
       "__ranges/data.h",
       "__ranges/drop_view.h",
       "__ranges/drop_while_view.h",
       "__ranges/elements_view.h",
       "__ranges/empty.h",
       "__ranges/empty_view.h",