[libc++] Implement P0288R9 (move_only_function)

[avogelsgesang]

Thanks for looking into this :) std::move_only_function is very high on the list of my favorite new C++23 features!

libcxx/include/__functional/move_only_function_impl.h

281

Is it more efficient to only set __status_ = NotEngaged? Afaict, this would overwrite only 1 instead of 48 bytes

(here and a couple of other places which set __storage_ = {}

295

redundant return before else?

361

std::bit_cast<__ReturnT (*)(...)> instead of std::bit_cast<void (*)(...)>?

Also, it seems there are no test cases which instantiate move_only_function with a return type != void?

361

I think this should also take _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT into account when casting to the function pointer.

As written now, for move_only_function<void () noexcept>, this operator() will contain a call to a non-noexcept function. The compiler will hence generate additional exception handling code. Also, this blocks tail call optimization (https://godbolt.org/z/39bn95cdT)

366

I think this can be implemented more efficiently by folding this switch with the indirect function call we are doing here anyway.

Proposed changes

Move this switch into __function_wrappers_impl::__call, taking _Store::_Status as a template parameter:

template<_Store::_Status status>
_LIBCPP_HIDE_FROM_ABI static _ReturnT
__call(_Store* store, _ArgTypes&&... __args) noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
    auto __doCall = [&](void* __functor) {
        return std::invoke(static_cast<_Functor _LIBCPP_MOVE_ONLY_FUNCTION_INV_QUALS>(*static_cast<_Functor*>(__functor)),
                         std::forward<_ArgTypes>(__args)...);
    }
    using enum _Store::_Status;
    if constexpr (status == _NotEngaged) {
      _LIBCPP_ASSERT(false, "Tried to call move_only_function which doesn't hold a callable object");
    }  else if constexpr (status == _TriviallyDestructible) {
        return __doCall(&__storage_.__trivially_destructible_.__data_);
    }  else if constexpr (status == _TriviallyRelocatable) {
        return __doCall(&__storage_.__trivially_relocatable_.__data_);
    }  else if constexpr (status == _Heap) {
        return __doCall(&__storage_.__large_.__data_);
    }
}

In __construct, the __storage.__large_.__call would then be assigned similar to

auto& __data   = __storage_.__large_;
__data.__call_ = std::bit_cast<void*>(&_FuncWraps::__call<_Store::_Status::_Heap>);

Because the __call_ member is always at the same position inside the __move_only_function_storage, we can then implement operator() as a simple

_LIBCPP_HIDE_FROM_ABI _ReturnT operator()(_ArgTypes... __args) _LIBCPP_MOVE_ONLY_FUNCTION_CV_REF
    noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
  return std::bit_cast<ReturnT (*)(_LIBCPP_MOVE_ONLY_FUNCTION_CV  _Store*, _ArgTypes...)>(__storage_.__large_.__call_)(
      &__storage, std::forward<_ArgTypes>(__args)...);

Why I think this is a good idea

Replacing the switch with a if constexpr chain guarantees that this switch is completely optimized away.

Futhermore for usages like

void setCallback(std::move_only_function<void()> cb);

void setCallbackWithGreetings(bool bye, const char* whom) {
     takesSomeCallback([=]() {
          std::cout << (bye ? "Goodbye " : "Hello ") << whom << "\n";
     });
}

the compiler can inline the lambda body into the __function_wrappers_impl::__call. The compiler can then fold the offset computation for __storage_.__large_.__data_ with the offset computations for whom and bye. With the previous implementation of operator() this would not have been possible since the __storage_.__large_.__data_ happens before the indirect call, while the whom & bye offset computations happened inside the indirect call.

[avogelsgesang]

libcxx/include/__functional/move_only_function_impl.h

204

__functor should probably be the last argument.

This function forwards all its arguments except for __functor.
Removing an argument from the front of the argument list means that all parameters must be "shifted" between the registers/on the stack.
If instead functor is the last argument, no arguments need to be moved around.

See https://godbolt.org/z/hnbe1xYdf

This is also beneficial for operator(): operator() has to add the functor to the argument list. Appending an argument is trivial, but prepending is expensive...

298

Not sure if this idea is blessed by the standard or undefined behavior, but:

After changing operator() to append instead of prepend the pointer to the functor, this could be rewritten to std::bit_cast<void*>(static_cast<UnrefFunc>(_func));, i.e. we could directly store the function pointer inside __call_ instead of a pointer to the _FuncWraps::__call dispatch function.

The operator() would call this function pointer with one additional argument. But at on the x64 calling conventions, it is fine to call a function with additional parameters. Additional parameters are simply ignored...

[avogelsgesang]

libcxx/include/__functional/move_only_function_impl.h

204

nevermind - on 2nd thought: this code is only removing the first argument if __function is a function pointer. If it is, e.g., a lambda then the first argument, i.e. the this pointer, will be replaced but all other arguments stay in their original position.

Similarly, operator() does not actually prepend an argument, but just replaces the first argument, i.e. the this pointer

298

nevermind - see other comment why this makes no sense

[lichray]

libcxx/include/__functional/move_only_function.h

27

We should aim for a macro-free implementation to benefit users.

libcxx/include/__functional/move_only_function_impl.h

71

In his CppCon 2017 talk, Louis @ldionne showed that embedding a vtable in the object storage is not an optimization compared to using a vptr even if we ignore the fact that embedded vtable uses more space. Also, mo-func of 6 x pointers in size may be too large. It's even larger than Swift's existential container (3-pointers + metadata + vptr).

204

Similarly, operator() does not actually prepend an argument, but just replaces the first argument, i.e. the this pointer

Exactly.

204

1. _ArgTypes&& - should consider passing objects by copy rather than references as an optimization in certain cases.
2. Please make sure that we don't have a design that works like the following: when move_only_function is initialized from a pointer to function, we need to dereference __functor first to reach the function pointer, and then make a call via that function pointer.

268

It seems that some logic is embedded in the mo-func body, rather than dispatched. __destroy_ is not sufficiently used.

360

Please make sure the type is ABI-compatible after adopting https://wg21.link/p2511/github. It is on the way to C++26.

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const.pass.cpp

84

We should test against behaviors, not guts. If the difference is not observable according to the standard, consider observing some extension such as a more strict noexcept.

[philnik]

New approach based on @Quuxplusone's feedback.

[philnik]

libcxx/include/__functional/move_only_function.h

27

If you have an idea on how to do that I'd be happy to try it, but I don't think writing the implementation 12 times is worth removing the macros.

libcxx/include/__functional/move_only_function_impl.h

71

Do you have any reasoning how large it should be? It's simple to change, since I don't know what the size should be.

123

Can the indirection be avoided for function pointers?

246

Take a look at https://wg21.link/p2511

360

I think the only things still relevant from this thread are P2511 and avoiding the indirection for function pointers. To make it simpler I added comments independent from this thread for these things.

[ldionne]

In the interest of making progress on this, let's do the following concrete action items in addition to what I left in the comments:

1. Extract a separate class to handle the SBO.
2. Survey other implementations and also other open source projects to see what approach they've taken.

The tricky thing with this patch is that several design questions are intertwined: support for trivial-relocation, size of the SBO and how to store the "virtual functions" are all interdependent.

libcxx/include/__config

141–142

Since move_only_function is new, why do we need an ABI macro to control this?

Edit: @philnik tells me that's because GCC doesn't support the attribute. What a shame. Since we want to keep code ABI compatible between Clang and GCC (when compiled using libc++), I guess we do need to hide that.

@philnik Can you please file a bug against GCC to start supporting the trivial_abi attribute and paste a link here? I think this is a pretty serious missed optimization that would be so easy to get. CC @jwakely for awareness.

libcxx/include/__functional/move_only_function_impl.h

2

General comment 1:

I think we should extract the logic to implement the small buffer optimization into its own piece instead of implementing it inside move_only_function. This isn't the last time we'll have to do this kind of optimization, and in fact it would have been nice to have this when std::function was written too. I can help with that, I have a local copy of an implementation of a __sbo class I had written when I did my own stab at any_invocable (which is now move_only_function), a long time ago.

123

The only way I can see that working is to reinterpret_cast the function pointer itself to the type that __call_ expects, and assign it to __call_ directly. However, that would assume that the __function_wrappers<_Func>::__call thunk is truly a no-op, which I think is always the case.

I think this is technically UB though, because you have to cast the function pointer back to its real type before calling it (which is exactly the point of the thunk). This is something that's extremely hard to express within the language, however it's also something I would perhaps expect to be trivial to optimize for the compiler. After all, the compiler will basically see a thunk that does absolutely nothing except jump somewhere else. I would expect that the compiler can just hoist one level of indirection.

Note: As pointed out by @philnik in live review, indeed functions can't have the same address, so I don't think this is an optimizations that compilers can perform. That being said, I think this would be doable if we had a way to tell the compiler that we don't care about the address of that object. I'm just thinking out loud, but should be we allowed to apply [[no_unique_address]] to functions? @rsmith @fhahn Any thoughts?

[ldionne]

libcxx/include/__functional/move_only_function_impl.h

6

General comment 2:

Fundamentally, we need to decide whether we're going to implement the function call dispatching using a classic vtable, or generate a "vtable" ourselves (either inlined in the object like you do right now, or not). This has to be thought through, but my initial preference would be to go for a manual vtable with one layer of indirection, since IIRC that's what I had the best results with when I investigated this with Dyno. IIRC, the observation was that you don't really pay for the additional level of indirection if you're calling the function over and over again, since it's hot in the cache anyway. Instead, you're better to just reduce the size of the object. This is a really tough call to make though, because we're operating with a lot of assumptions and we have to make this work well for all possible workloads, which is simply impossible.

Probably relevant things to look at (sorry for the plug): https://github.com/ldionne/dyno and http://ldionne.com/cppnow-2018-runtime-polymorphism. It's been a while but I had done a survey of various techniques in that area and I think the conclusions might still be relevant, even if that's a little bit dated.

65

General comment: Please make sure you have _LIBCPP_ASSERTs in place for UB in this class, and tests that these assertions work as intended.

244

IMO this is too large. I believe that types with sizeof(T) == 32 AND that are trivially move constructible/destructible AND that we want to type erase are going to be quite rare. I think that most types will be either smaller, or will be non-trivial. Shooting from the hip, I would use something like 2*sizeof(void*) at most, but we definitely need to look at what other implementations are doing, and also what other common utilities like this do (let's do a quick survey in open source libraries, e.g. have Folly or Abseil already shipped something like this, and if so, is there something we can learn from their experience?).

252

I think we should make it possible to store non-trivially-fooable types in the small buffer. IIUC you only need that constraint in order to implement swap, but you should be able to handle that by adding yet another function to the vtable. This would create a size issue right now, but wouldn't be a concern anymore if we move to a remote vtable.

[jwakely]

In D130631#3824399, @ldionne wrote:

2. Survey other implementations and also other open source projects to see what approach they've taken.

GCC's implementation (which could change before we declare C++23 support non-experimental) has a SBO buffer that is big enough to store a pointer to member function and an object pointer, i.e. a simple delegate.

Please do file a GCC request for trivial_abi, I don't think that's on anybody's radar yet.

[lichray]

libcxx/include/__functional/move_only_function.h

27

No macro and maintainable. Here is an example: https://github.com/zhihaoy/nontype_functional/blob/main/include/std23/move_only_function.h
With C++ explicit object member function, you can also turn the six operator() into one.

libcxx/include/__functional/move_only_function_impl.h

71

According to STL the person, it is reasonable to "store a std::string locally." To libc++, that's 24 bytes; 32 bytes for the whole mv-func object with a vptr.

[philnik]

• Address some of the comments

libcxx/include/__config

141–142

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107187

libcxx/include/__functional/move_only_function.h

27

I don't think that implementation is conforming. The standard explicitly states that there have to be partial specializations for each combination of cv, ref and noex (http://eel.is/c++draft/func.wrap.move#general-1). I didn't ask before, but how exactly does it affect users whether the implementation is macro-free or not?

libcxx/include/__functional/move_only_function_impl.h

244

library	name	size	buffer size
Abseil	absl::any_invocable	32	16
libstdc++	std::move_only_function	40	24
folly	folly::Function	64	48
LLVM	llvm::unique_function	32	24
HPX	hpx::move_only_function	40	24
MSVC STL	std::move_only_function	64	56

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const.pass.cpp

84

What are you talking about?

[ldionne]

libcxx/include/__functional/move_only_function.h

27

I agree with @philnik that this isn't conforming, although I think it's only pedantically non-conforming. In practice, I would expect that it works for most users.

Most importantly, it seems to me like the spec is too narrow here. What the standard *really* wants to say is that move_only_function can handle any combination of cv noexcept ref, but I don't think it was ever an explicit goal to say that it would be achieved via specialization specifically.

@jwakely @lichray Do you agree this is overspecified? If so, I could write a NB comment about it and we could relax the specification. Otherwise, I would argue that the current approach taken by @philnik is probably the right one, even though I agree it's kind of lame to be required by the Standard to use the X macro idiom.

libcxx/include/__functional/move_only_function_common.h

32

Let's call this in a way that it's move_only_function specific. Maybe _MoveOnlyFunctionVtable or whatever. Just std::_VTable is taking a pretty general name and assigning it specific meaning, which is weird.

libcxx/include/__functional/move_only_function_impl.h

100

If we do like llvm::unique_function (and I think we should), then we would have two sorts of vtables (pseudocode obviously):

struct _TrivialMoveOnlyFunctionVTable {
  auto __call_;
};

struct _NonTrivialMoveOnlyFunctionVTable : _TrivialMoveOnlyFunctionVTable {
  auto __destroy_;
  auto __move_;
};

We could use the pointer union trick to store whether the vtable is for a trivial type or not, which would replace your check for __destroy_ == nullptr in __reset(). IMO that would be slightly better.

We should implement a pointer union like type in libc++, that's something we should have had for a while. Give me a few days to get to it, and if I don't manage to I'll let you know and you can treat yourself.

159

How do you know that __func.__vtable_ is compatible with this function's vtable? And by that I mean precisely: how do you know that this function's vtable.__call_ (and __destroy_ and __move_) have exactly the same signature as __func.__vtable_'s? If they are not exactly the same, it's going to be UB to call them through pointers to different types.

From live review: you say this is definitely UB. First, please ensure to call out things like that explicitly. Second, I don't think we should perform this optimization unless we have some sort of blessing from the compiler (through a builtin or something like that).

244

Shooting from the hip, I would go for an implementation like llvm::unique_function, with 32 total size and 24 SBO. But it would be great to have more data about how these types are used. Unfortunately that's pretty difficult to get.

@EricWF Do you have any way to gather some data on your code base that would help us pick something here?

libcxx/include/__utility/small_buffer.h

38 ↗

(On Diff #467116)

I think we should allow storing non-trivially movable types in the SBO. This would require another "virtual" function to perform the move, but I think that's worth the trouble. Concretely, the size of the vtable isn't a huge issue.

46 ↗

(On Diff #467116)

IMO it would be nice if __small_buffer had a constructor that took an object. It would then encapsulate way more logic. That does mean that __small_buffer would have to know how to allocate and deallocate, but that can be done via template parameters. I think that would simplify the implementation of move_only_function quite a bit.

It would also make sense (?) if __small_buffer could be swapped, IMO. That also requires additional knowledge that should be parameterizable.

56 ↗

(On Diff #467116)

Do we need launder?

68 ↗

(On Diff #467116)

You'll need to guard this for exceptions once you store non-trivial types in the buffer.

81 ↗

(On Diff #467116)

This allows dropping the dependency on std::array, which doesn't add much. The _BufferSize is always > 0.

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.move/call_disengaged.pass.cpp

1 ↗

(On Diff #467116)

Can you call this assert.<whatever> for consistency?

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/common.h

16–17

Please keep this in each file, even if that means duplicating it. Seeing a variable named called in the tests coming from seamingly nowhere is really weird IMO. And the duplication isn't much.

83

This is weird too - this has a different behavior depending on whether the function returns void or not. I understand you were maybe trying to reduce code duplication, but this is kind of spaghetti in return, IMO. Instead, consider always setting a bool to express that the function was called. The only difference will then become whether you're taking an argument or not and what you're returning, which seems better:

struct NonTrivial {
  NonTrivial() = default;
  NonTrivial(MoveCounter, bool* set_on_call) {}
  NonTrivial(std::initializer_list<int>&, MoveCounter, bool* set_on_call) {}
  NonTrivial(NonTrivial&&) noexcept(false) {} // todo
  ~NonTrivial() {}

  void operator()() const noexcept { *called_ = true; }
  int operator()(int i) const noexcept { *called_ = true; return i; }
};

Also, I would suggest not using a global here. It's not constexpr friendly and it's also not the best style, even though I understand it results in more "compact" code.

[ldionne]

libcxx/include/__functional/move_only_function_impl.h

62

https://wg21.link/p2548 copyable_function is making progress through the committee. We should discuss how these two types are going to interoperate and whether that should inform the representation we choose for move_only_function. In particular, it would be a nice QOI property to have move_only_function(copyable_function&&) just steal the guts of the copyable_function and make no allocation.

[philnik]

Address some more comments

libcxx/include/__functional/move_only_function_impl.h

71

We've got multiple threads discussing the this, so I'm closing some.

252

The question of using the SBO for non-trivially relocatable types is spanning multiple threads, so I'm closing this one.

libcxx/include/__utility/small_buffer.h

38 ↗

(On Diff #467116)

This would also make move_only_function not trivially relocatable anymore.

56 ↗

(On Diff #467116)

I think the answer is yes, because we might never have destroyed a trivial object that was in __buffer_ before, but I'm not familiar enough with the technicalities of object lifetime to be confident in answering the question.

[philnik]

Generate files

[philnik]

Try to fix CI

[philnik]

Next try

[ldionne]

libcxx/include/__functional/move_only_function_impl.h

40–55

Is there a reason why you allow these macros to *not* be defined? I would simply document the macros that this file needs in a comment and also have a #ifndef #error #endif for each of them.

62

I think the question here is basically whether we will want to have non-trivially-movable types in the SBO of copyable_function. If we do, then we won't be able to steal the guts, otherwise we will (assuming we use a SBO size that is no larger than that of move-only-function).

68

Please add documentation explaining the design choices we made and why. Basically a summary of this review. You'll thank yourself in a few months/years -- it's much much easier to do it right now while it's fresh.

77

This doesn't look super useful anymore.

102

104

I would call those __trivial_vtable and __nontrivial_vtable instead, since they are vtables and not vpointers.

105–108

111

_LIBCPP_HIDE_FROM_ABI here and wherever else you need it -- please make a pass.

131

You could use an immediately-invoked lambda here to avoid defining a separate function, since it's used exactly once.

libcxx/include/__utility/pointer_int_pair.h

1 ↗

(On Diff #479860)

This one in a separate patch too, please!

28–30 ↗

(On Diff #479860)

36 ↗

(On Diff #479860)

We should implement _PointerLikeTraits for __pointer_int_pair so that we can chain __pointer_int_pairs.

47 ↗

(On Diff #479860)

Let's require std::is_signed_v unless you want to have some fun making sure it works with signed types.

49 ↗

(On Diff #479860)

Can you please make sure that you have tests with a fancy pointer class?

58 ↗

(On Diff #479860)

Lets explicitly do __pointer_int_pair(__pointer_int_pair const&) = default, and so on for the move constructor and the assignment operators. It's nice documentation to state that it's trivially whatever-able just like one would expect.

59 ↗

(On Diff #479860)

constexpr? That will make it constinit-able.

62 ↗

(On Diff #479860)

I think this assertion is incorrect. Let's say you have something like this:

// int value: 15 aka 1111 binary
// number of bits free in the pointer: 4
// number of bits in use: 2
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 0000 // before you store anything into the pointer
xxxxxxxxxxxxxxxxxxxxxxxxxxxx11 1100 // after you store 15 into the pointer (it overflowed)
xxxxxxxxxxxxxxxxxxxxxxxxxxxx11 1111 // assuming you were using the 2 lower bits of the pointer to store something like int-value=3

Your assertion will pass but you still overflowed.

67 ↗

(On Diff #479860)

constexpr

72 ↗

(On Diff #479860)

This could be constexpr?

76–78 ↗

(On Diff #479860)

Looking at this, I am wondering whether we actually want to give it a pointer-like interface at all. This is a pair, not a pointer. Maybe we just want __first() and __second()? That would simplify the API.

And we should also make it work with structured bindings by making it a tuple-like class.

libcxx/include/__utility/small_buffer.h

1 ↗

(On Diff #479860)

Can you split this class off into its own patch?

32–33 ↗

(On Diff #479860)

That way we can decide from move_only_function the additional criteria for storing the type in the SBO.

Nevermind, this adds too much complexity in the move constructor for little benefit since the only user (for now) would have it be trivially relocatable anyways.

33 ↗

(On Diff #479860)

Please document the design of the class, in particular the fact that it only ever stores trivially movable objects in the buffer, which allows it to be trivially relocatable. Also mention that the users of the class are expected to manage the lifetime of the object inside the buffer.

38 ↗

(On Diff #467116)

So the tradeoff here is that either we accept non-trivially movable types in the SBO, or we only accept trivially movable types and then we can guarantee that the SBO is trivially relocatable.

I think this decision boils down to what's the most important use case for move_only_function. In live review, I said I thought it would be used mostly as a function parameter, however you rightly point out that we'll have function_ref for that. So for times where we don't want to actually store the move_only_function, we can just use function_ref and there's never an allocation.

So I think it would make sense to keep it trivially relocatable, as in the current patch.

56 ↗

(On Diff #467116)

I think we need to launder for this case:

struct Foo { };
struct Bar { };

buf.construct<Foo>(Foo{});
Foo* foo = buf.__get<Foo>();

use(buf);
Bar* bar = buf.__get<Bar>();


// somewhere else
void use(__small_buffer& buf) {
  buf.construct<Bar>(Bar{});
}

libcxx/test/libcxx/utilities/pointer_int_pair.pass.cpp

10

Maybe there should be more tests? This is a pretty fundamental utility.

Also please test chaining, etc.

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/nullptr.pass.cpp

71

return 0 everywhere please!

libcxx/test/support/type_algorithms.h

121

Maybe this should take an enum that you can bit-or to say which combinations you want?

[philnik]

Address some more comments

libcxx/include/__functional/move_only_function_impl.h

40–55

There are a two reasons:

1. It's a lot harder to define _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS
2. Having defaults for them allows editors to parse the file properly, instead of generating errors all over the place.

libcxx/include/__utility/pointer_int_pair.h

59 ↗

(On Diff #479860)

Doesn't apply anymore.

72 ↗

(On Diff #479860)

I guess so, but I don't think it makes a lot of sense to mark constexpr since nothing else is constexpr, or is there some benefit?

[ldionne]

libcxx/include/__functional/move_only_function_impl.h

74

I would add

// This is also a nice place to document how we're storing the vtable, i.e. explain that we're either pointing to a TrivialVTable or a non-trivial one based on the bool.
using _VTableStorage = __pointer_int_pair<const _TrivialVTable*, bool, bitfield_width(1)>;

104

Can you use a more descriptive name here?

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_expected``                            ``202202L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_forward_like``                        ``202207L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_invoke_r``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_move_only_function``                  *unimplemented*
+    ``__cpp_lib_move_only_function``                  ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_optional``                            ``202110L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_out_ptr``                             *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk``                        *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk_by``                     *unimplemented*

libcxx/docs/ReleaseNotes.rst

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

libcxx/docs/Status/Cxx2bPapers.csv

 "`P1425R4 <https://wg21.link/P1425R4>`__","LWG","Iterators pair constructors for stack and queue","June 2021","|Complete|","14.0","|ranges|"
 "`P1518R2 <https://wg21.link/P1518R2>`__","LWG","Stop overconstraining allocators in container deduction guides","June 2021","|Complete|","13.0"
 "`P1659R3 <https://wg21.link/P1659R3>`__","LWG","starts_with and ends_with","June 2021","","","|ranges|"
 "`P1951R1 <https://wg21.link/P1951R1>`__","LWG","Default Arguments for pair Forwarding Constructor","June 2021","|Complete|","14.0"
 "`P1989R2 <https://wg21.link/P1989R2>`__","LWG","Range constructor for std::string_view","June 2021","|Complete|","14.0","|ranges|"
 "`P2136R3 <https://wg21.link/P2136R3>`__","LWG","invoke_r","June 2021","",""
 "`P2166R1 <https://wg21.link/P2166R1>`__","LWG","A Proposal to Prohibit std::basic_string and std::basic_string_view construction from nullptr","June 2021","|Complete|","13.0"
 "","","","","",""
-"`P0288R9 <https://wg21.link/P0288R9>`__","LWG","``any_invocable``","October 2021","",""
+"`P0288R9 <https://wg21.link/P0288R9>`__","LWG","``move_only_function``","October 2021","|Complete|","16.0"
 "`P0798R8 <https://wg21.link/P0798R8>`__","LWG","Monadic operations for ``std::optional``","October 2021","|Complete|","14.0"
 "`P0849R8 <https://wg21.link/P0849R8>`__","LWG","``auto(x)``: ``DECAY_COPY`` in the language","October 2021","|Complete|","14.0"
 "`P1072R10 <https://wg21.link/P1072R10>`__","LWG","``basic_string::resize_and_overwrite``","October 2021","|Complete|","14.0"
 "`P1147R1 <https://wg21.link/P1147R1>`__","LWG","Printing ``volatile`` Pointers","October 2021","|Complete|","14.0"
 "`P1272R4 <https://wg21.link/P1272R4>`__","LWG","Byteswapping for fun&&nuf","October 2021","|Complete|","14.0"
 "`P1675R2 <https://wg21.link/P1675R2>`__","LWG","``rethrow_exception`` must be allowed to copy","October 2021","",""
 "`P2077R3 <https://wg21.link/P2077R3>`__","LWG","Heterogeneous erasure overloads for associative containers","October 2021","",""
 "`P2251R1 <https://wg21.link/P2251R1>`__","LWG","Require ``span`` & ``basic_string_view`` to be Trivially Copyable","October 2021","|Complete|","14.0"

libcxx/include/CMakeLists.txt

set(files
   __functional/default_searcher.h
   __functional/function.h
   __functional/hash.h
   __functional/identity.h
   __functional/invoke.h
   __functional/is_transparent.h
   __functional/mem_fn.h
   __functional/mem_fun_ref.h
+  __functional/move_only_function.h
+  __functional/move_only_function_common.h
+  __functional/move_only_function_impl.h
   __functional/not_fn.h
   __functional/operations.h
   __functional/perfect_forward.h
   __functional/pointer_to_binary_function.h
   __functional/pointer_to_unary_function.h
   __functional/ranges_operations.h
   __functional/reference_wrapper.h
   __functional/unary_function.h

libcxx/include/__config

 // Don't export the legacy __vector_base_common class and its methods from the built library.
 #    define _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
 // According to the Standard, `bitset::operator[] const` returns bool
 #    define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
 // Remove the base 10 implementation of std::to_chars from the dylib.
 // The implementation moved to the header, but we still export the symbols from
 // the dylib for backwards compatibility.
 #    define _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
+// Enable clang::trivial_abi for std::move_only_function
+#    define _LIBCPP_ABI_SMALL_BUFFER_TRIVIAL_ABI
 #  elif _LIBCPP_ABI_VERSION == 1
 #    if !(defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF))
 // Enable compiling copies of now inline methods into the dylib to support
 // applications compiled against older libraries. This is unnecessary with
 // COFF dllexport semantics, since dllexport forces a non-inline definition
 // of inline functions to be emitted anyway. Our own non-inline copy would
 // conflict with the dllexport-emitted copy, so we disable it. For XCOFF,
 // the linker will take issue with the symbols in the shared object if the

libcxx/include/__functional/move_only_function.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_H
+#define _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+// move_only_function design:
+//
+// move_only_function has a small buffer with a size of `3 * sizeof(void*)` bytes. This buffer can only be used when the
+// object that should be stored is trivially relocatable (currently only when it is trivially move constructible and
+// trivially destructible). There is also a bool in the lower bits of the vptr stored which is set when the contained
+// object is not trivially destructible.
+//
+// trivially relocatable: It would also be possible to store nothrow_move_constructible types, but that would mean
+// that move_only_function itself would not be trivially relocatable anymore. The decision to keep move_only_function
+// trivially relocatable was made because we expect move_only_function to be mostly used to store a functor. To only
+// forward functors there is std::function_ref (not voted in yet, expected in C++26).
+//
+// buffer size: We did a survey of six implementations from various vendors. Three of them had a buffer size of 24 bytes
+// on 64 bit systems. This also allows storing a std::string or std::vector inside the small buffer (once the compiler
+// has full support of trivially_relocatable annotations).
+//
+// trivially-destructible bit: This allows us to keep the overall binary size smaller because we don't have to store
+// a pointer to a noop function inside the vtable. It also avoids loading the vtable during destruction, potentially
+// resulting in fewer cache misses. The downside is that calling the function now also requires setting the lower bits
+// of the pointer to zero, but this is a very fast operation on modern CPUs.
+
+// NOLINTBEGIN(readability-duplicate-include)
+#  define _LIBCPP_IN_MOVE_ONLY_FUNCTION_H
+
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+#  include <__functional/move_only_function_impl.h>
+
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+#  include <__functional/move_only_function_impl.h>
+
+#  undef _LIBCPP_IN_MOVE_ONLY_FUNCTION_H
+// NOLINTEND(readability-duplicate-include)
+
+#endif // _LIBCPP_STD_VER > 20
+
+#endif // _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_H

libcxx/include/__functional/move_only_function_common.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_COMMON_H
+#define _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_COMMON_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class...>
+class move_only_function;
+
+template <class>
+struct __is_move_only_function : false_type {};
+
+template <class... _Args>
+struct __is_move_only_function<move_only_function<_Args...>> : true_type {};
+
+template <class _BufferT, class _ReturnT, class... _ArgTypes>
+struct _MoveOnlyFunctionTrivialVTable {
+  using _CallFunc = _ReturnT(_BufferT&, _ArgTypes...);
+
+  _CallFunc* __call_;
+};
+
+template <class _BufferT, class _ReturnT, class... _ArgTypes>
+struct _MoveOnlyFunctionNonTrivialVTable : _MoveOnlyFunctionTrivialVTable<_BufferT, _ReturnT, _ArgTypes...> {
+  using _DestroyFunc = void(_BufferT&) noexcept;
+
+  _DestroyFunc* __destroy_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_COMMON_H

libcxx/include/__functional/move_only_function_impl.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// This header is unguarded on purpose. This header is an implementation detail of move_only_function.h
+// and generates multiple versions of std::move_only_function
+
+#include <__config>
+#include <__functional/invoke.h>
+#include <__functional/move_only_function_common.h>
+#include <__memory/construct_at.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/is_trivially_move_constructible.h>
+#include <__utility/exchange.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/pointer_int_pair.h>
+#include <__utility/small_buffer.h>
+#include <__utility/swap.h>
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <new>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_IN_MOVE_ONLY_FUNCTION_H
+#  error This header should only be included from move_only_function.h
+#endif
+
+#ifndef _LIBCPP_MOVE_ONLY_FUNCTION_CV
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_CV
+#endif
+
+#ifndef _LIBCPP_MOVE_ONLY_FUNCTION_REF
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_REF
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS _LIBCPP_MOVE_ONLY_FUNCTION_CV&
+#else
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS _LIBCPP_MOVE_ONLY_FUNCTION_CV _LIBCPP_MOVE_ONLY_FUNCTION_REF
+#endif
+
+#ifndef _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT false
+#endif
+
+#define _LIBCPP_MOVE_ONLY_FUNCTION_CVREF _LIBCPP_MOVE_ONLY_FUNCTION_CV _LIBCPP_MOVE_ONLY_FUNCTION_REF
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef _LIBCPP_ABI_MOVE_ONLY_FUNCTION_TRIVIAL_ABI
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_TRIVIAL_ABI [[_Clang::__trivial_abi__]]
+#else
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_TRIVIAL_ABI
+#endif
+
+template <class...>
+class move_only_function;
+
+template <class _ReturnT, class... _ArgTypes>
+class _LIBCPP_MOVE_ONLY_FUNCTION_TRIVIAL_ABI move_only_function<_ReturnT(
+    _ArgTypes...) _LIBCPP_MOVE_ONLY_FUNCTION_CVREF noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT)> {
+private:
+  static constexpr size_t __buffer_size_      = 3 * sizeof(void*);
+  static constexpr size_t __buffer_alignment_ = alignof(void*);
+  using _BufferT                              = __small_buffer<__buffer_size_, __buffer_alignment_>;
+
+  using _TrivialVTable    = _MoveOnlyFunctionTrivialVTable<_BufferT, _ReturnT, _ArgTypes...>;
+  using _NonTrivialVTable = _MoveOnlyFunctionNonTrivialVTable<_BufferT, _ReturnT, _ArgTypes...>;
+
+  template <class _Functor>
+  static constexpr _TrivialVTable __trivial_vtable_ = {
+      .__call_ = [](_BufferT& __buffer, _ArgTypes... __args) noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) -> _ReturnT {
+        // TODO: Use std::invoke_r once P2136 is implemented
+        return std::invoke(static_cast<_Functor _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS>(*__buffer.__get<_Functor>()),
+                           std::forward<_ArgTypes>(__args)...);
+      }};
+
+  template <class _Functor>
+  static constexpr _NonTrivialVTable __non_trivial_vtable_{
+      __trivial_vtable_<_Functor>,
+      [](_BufferT& __buffer) noexcept -> void {
+        std::destroy_at(__buffer.__get<_Functor>());
+        __buffer.__dealloc<_Functor>();
+      },
+  };
+
+  template <class _Functor>
+  _LIBCPP_HIDE_FROM_ABI __pointer_bool_pair<const _TrivialVTable*> __get_vptr() {
+    if constexpr (_BufferT::__fits_in_buffer<_Functor> && is_trivially_destructible_v<_Functor>) {
+      return {&__trivial_vtable_<_Functor>, false};
+    } else {
+      return {&__non_trivial_vtable_<_Functor>, true};
+    }
+  }
+
+  template <class _VT>
+  static constexpr bool __is_callable_from = [] {
+    using _DVT = decay_t<_VT>;
+    if (_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
+      return is_nothrow_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_CVREF, _ArgTypes...> &&
+             is_nothrow_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS, _ArgTypes...>;
+    } else {
+      return is_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_CVREF, _ArgTypes...> &&
+             is_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS, _ArgTypes...>;
+    }
+  }();
+
+  template <class _Func, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void __construct(_Args&&... __args) {
+    static_assert(is_constructible_v<decay_t<_Func>, _Func>);
+
+    using _StoredFunc = decay_t<_Func>;
+    __vtable_         = __get_vptr<_StoredFunc>();
+    __buffer_.__construct<_StoredFunc>(std::forward<_Args>(__args)...);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __reset() {
+    if (__vtable_.__get_value())
+      static_cast<const _NonTrivialVTable*>(__vtable_.__get_ptr())->__destroy_(__buffer_);
+    __vtable_ = {};
+  }
+
+public:
+  using result_type = _ReturnT;
+
+  // [func.wrap.move.ctor]
+  move_only_function() noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI move_only_function(nullptr_t) noexcept {}
+  _LIBCPP_HIDE_FROM_ABI move_only_function(move_only_function&& __other) noexcept
+      : __vtable_(__other.__vtable_), __buffer_(std::move(__other.__buffer_)) {
+    __other.__vtable_ = {};
+  }
+
+  template <class _Func>
+    requires(!is_same_v<remove_cvref_t<_Func>, move_only_function> && !__is_inplace_type<_Func>::value &&
+             __is_callable_from<_Func>)
+  _LIBCPP_HIDE_FROM_ABI move_only_function(_Func&& __func) noexcept {
+    using _StoredFunc = decay_t<_Func>;
+
+    if constexpr ((is_pointer_v<_StoredFunc> && is_function_v<remove_pointer_t<_StoredFunc>>) ||
+                  is_member_function_pointer_v<_StoredFunc>) {
+      if (__func != nullptr) {
+        __vtable_ = __get_vptr<_StoredFunc>();
+        static_assert(_BufferT::__fits_in_buffer<_StoredFunc>);
+        __buffer_.__construct<_StoredFunc>(std::forward<_Func>(__func));
+      }
+    } else if constexpr (__is_move_only_function<_StoredFunc>::value) {
+      if (__func) {
+        __vtable_ = std::exchange(__func.__vtable_, {});
+        __buffer_ = std::move(__func.__buffer_);
+      }
+    } else {
+      __construct<_Func>(std::forward<_Func>(__func));
+    }
+  }
+
+  template <class _Func, class... _Args>
+    requires is_constructible_v<decay_t<_Func>, _Args...> && __is_callable_from<_Func>
+  _LIBCPP_HIDE_FROM_ABI explicit move_only_function(in_place_type_t<_Func>, _Args&&... __args) {
+    static_assert(is_same_v<decay_t<_Func>, _Func>);
+    __construct<_Func>(std::forward<_Args>(__args)...);
+  }
+
+  template <class _Func, class _InitListType, class... _Args>
+    requires is_constructible_v<decay_t<_Func>, initializer_list<_InitListType>&, _Args...> && __is_callable_from<_Func>
+  _LIBCPP_HIDE_FROM_ABI explicit move_only_function(
+      in_place_type_t<_Func>, initializer_list<_InitListType> __il, _Args&&... __args) {
+    static_assert(is_same_v<decay_t<_Func>, _Func>);
+    __construct<_Func>(__il, std::forward<_Args>(__args)...);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI move_only_function& operator=(move_only_function&& __other) noexcept {
+    move_only_function(std::move(__other)).swap(*this);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI move_only_function& operator=(nullptr_t) noexcept {
+    __reset();
+    return *this;
+  }
+
+  template <class _Func>
+    requires(!is_same_v<remove_cvref_t<_Func>, move_only_function> && !__is_inplace_type<_Func>::value &&
+             __is_callable_from<_Func>)
+  _LIBCPP_HIDE_FROM_ABI move_only_function& operator=(_Func&& __func) {
+    move_only_function(std::forward<_Func>(__func)).swap(*this);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~move_only_function() { __reset(); }
+
+  // [func.wrap.move.inv]
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept { return __vtable_.__get_ptr() != nullptr; }
+
+  _LIBCPP_HIDE_FROM_ABI _ReturnT operator()(_ArgTypes... __args) _LIBCPP_MOVE_ONLY_FUNCTION_CVREF
+      noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
+    _LIBCPP_ASSERT(static_cast<bool>(*this), "Tried to call a disengaged move_only_function");
+    const auto __call = static_cast<_ReturnT (*)(_BufferT&, _ArgTypes...)>(__vtable_.__get_ptr()->__call_);
+    return __call(__buffer_, std::forward<_ArgTypes>(__args)...);
+  }
+
+  // [func.wrap.move.util]
+  _LIBCPP_HIDE_FROM_ABI void swap(move_only_function& __other) noexcept {
+    std::swap(__vtable_, __other.__vtable_);
+    std::swap(__buffer_, __other.__buffer_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend void swap(move_only_function& __lhs, move_only_function& __rhs) noexcept {
+    __lhs.swap(__rhs);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend bool operator==(const move_only_function& __func, nullptr_t) noexcept { return !__func; }
+
+private:
+  __pointer_bool_pair<const _TrivialVTable*> __vtable_ = {};
+  mutable _BufferT __buffer_;
+
+  template <class...>
+  friend class move_only_function;
+};
+
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_CV
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_REF
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_CVREF
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/include/functional

 #include <__functional/compose.h>
 #include <__functional/default_searcher.h>
 #include <__functional/function.h>
 #include <__functional/hash.h>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/mem_fn.h> // TODO: deprecate
 #include <__functional/mem_fun_ref.h>
+#include <__functional/move_only_function.h>
 #include <__functional/not_fn.h>
 #include <__functional/operations.h>
 #include <__functional/pointer_to_binary_function.h>
 #include <__functional/pointer_to_unary_function.h>
 #include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h> // TODO: deprecate
 #include <__functional/unary_negate.h>

libcxx/include/module.modulemap.in

module depr [extern_c] {
     }
     module wctype_h {
       @requires_LIBCXX_ENABLE_WIDE_CHARACTERS@
       header "wctype.h"
       export *
     }
   }
 
+  module __math {
+    module log2i { private header "__math/log2i.h" }
+  }
+
   // <complex.h> and <tgmath.h> are not C headers in any real sense, do not
   // allow their use in extern "C" contexts.
   module complex_h {
     header "complex.h"
     export ccomplex
     export *
   }
   module tgmath_h {
module __functional {
       module function                   { private header "__functional/function.h" }
       module hash                       { private header "__functional/hash.h" }
       module hash_fwd                   { private header "__fwd/hash.h" }
       module identity                   { private header "__functional/identity.h" }
       module invoke                     { private header "__functional/invoke.h" }
       module is_transparent             { private header "__functional/is_transparent.h" }
       module mem_fn                     { private header "__functional/mem_fn.h" }
       module mem_fun_ref                { private header "__functional/mem_fun_ref.h" }
+      module move_only_function         { private header "__functional/move_only_function.h" }
+      module move_only_function_common  { private header "__functional/move_only_function_common.h" }
+      module move_only_function_impl    { private textual header "__functional/move_only_function_impl.h" }
       module not_fn                     { private header "__functional/not_fn.h" }
       module operations                 { private header "__functional/operations.h" }
       module perfect_forward            { private header "__functional/perfect_forward.h" }
       module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
       module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
       module ranges_operations          { private header "__functional/ranges_operations.h" }
       module reference_wrapper          { private header "__functional/reference_wrapper.h" }
       module unary_function             { private header "__functional/unary_function.h" }
module __utility {
       module forward             { private header "__utility/forward.h" }
       module forward_like        { private header "__utility/forward_like.h" }
       module in_place            { private header "__utility/in_place.h" }
       module integer_sequence    { private header "__utility/integer_sequence.h" }
       module move                { private header "__utility/move.h" }
       module pair                { private header "__utility/pair.h" }
       module pair_fwd            { private header "__fwd/pair.h" }
       module piecewise_construct { private header "__utility/piecewise_construct.h" }
+      module pointer_int_pair    { private header "__utility/pointer_int_pair.h" }
       module priority_tag        { private header "__utility/priority_tag.h" }
       module rel_ops             { private header "__utility/rel_ops.h" }
       module small_buffer        { private header "__utility/small_buffer.h" }
       module swap                { private header "__utility/swap.h" }
       module to_underlying       { private header "__utility/to_underlying.h" }
       module transaction         { private header "__utility/transaction.h" }
       module unreachable         { private header "__utility/unreachable.h" }
     }

libcxx/include/version

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

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__functional/default_searcher.h> // expected-error@*:* {{use of private header from outside its module: '__functional/default_searcher.h'}}
 #include <__functional/function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/function.h'}}
 #include <__functional/hash.h> // expected-error@*:* {{use of private header from outside its module: '__functional/hash.h'}}
 #include <__functional/identity.h> // expected-error@*:* {{use of private header from outside its module: '__functional/identity.h'}}
 #include <__functional/invoke.h> // expected-error@*:* {{use of private header from outside its module: '__functional/invoke.h'}}
 #include <__functional/is_transparent.h> // expected-error@*:* {{use of private header from outside its module: '__functional/is_transparent.h'}}
 #include <__functional/mem_fn.h> // expected-error@*:* {{use of private header from outside its module: '__functional/mem_fn.h'}}
 #include <__functional/mem_fun_ref.h> // expected-error@*:* {{use of private header from outside its module: '__functional/mem_fun_ref.h'}}
+#include <__functional/move_only_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/move_only_function.h'}}
+#include <__functional/move_only_function_common.h> // expected-error@*:* {{use of private header from outside its module: '__functional/move_only_function_common.h'}}
+#include <__functional/move_only_function_impl.h> // expected-error@*:* {{use of private header from outside its module: '__functional/move_only_function_impl.h'}}
 #include <__functional/not_fn.h> // expected-error@*:* {{use of private header from outside its module: '__functional/not_fn.h'}}
 #include <__functional/operations.h> // expected-error@*:* {{use of private header from outside its module: '__functional/operations.h'}}
 #include <__functional/perfect_forward.h> // expected-error@*:* {{use of private header from outside its module: '__functional/perfect_forward.h'}}
 #include <__functional/pointer_to_binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_binary_function.h'}}
 #include <__functional/pointer_to_unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_unary_function.h'}}
 #include <__functional/ranges_operations.h> // expected-error@*:* {{use of private header from outside its module: '__functional/ranges_operations.h'}}
 #include <__functional/reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__functional/reference_wrapper.h'}}
 #include <__functional/unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_function.h'}}

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 fstream mutex
 fstream ostream
 fstream string
 fstream type_traits
 fstream typeinfo
 fstream version
 functional array
 functional atomic
+functional climits
 functional cstddef
 functional cstdint
 functional cstdlib
 functional cstring
 functional exception
 functional initializer_list
 functional iosfwd
 functional limits

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.move/assert.engaged.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+#include <functional>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  std::move_only_function<void()> func;
+  TEST_LIBCPP_ASSERT_FAILURE(func(), "Tried to call a disengaged move_only_function");
+}

libcxx/test/libcxx/utilities/pointer_int_pair.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include "test_macros.h"
+
+TEST_DIAGNOSTIC_PUSH
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wprivate-header")
+#include <__utility/pointer_int_pair.h>
+TEST_DIAGNOSTIC_POP
+
+#include <cassert>
+
+int main(int, char**) {
+  {
+    std::__pointer_int_pair<int*, 1> pair = nullptr;
+    assert(pair.__get_value() == 0);
+    assert(pair.__get_ptr() == nullptr);
+  }
+  {
+    std::__pointer_int_pair<int*, 1> pair(nullptr, 1);
+    assert(pair.__get_value() == 1);
+    assert(pair.__get_ptr() == nullptr);
+  }
+  {
+    static_assert(alignof(int) <= 4);
+    std::__pointer_int_pair<int*, 1> pair(reinterpret_cast<int*>(4), 0);
+    assert(pair.__get_value() == 0);
+    assert(pair.__get_ptr() == reinterpret_cast<int*>(4));
+  }
+}

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

 #     error "__cpp_lib_invoke_r should have the value 202106L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_invoke_r
 #     error "__cpp_lib_invoke_r should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_move_only_function
-#     error "__cpp_lib_move_only_function should be defined in c++2b"
-#   endif
-#   if __cpp_lib_move_only_function != 202110L
-#     error "__cpp_lib_move_only_function should have the value 202110L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_move_only_function
-#     error "__cpp_lib_move_only_function should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_move_only_function
+#   error "__cpp_lib_move_only_function should be defined in c++2b"
+# endif
+# if __cpp_lib_move_only_function != 202110L
+#   error "__cpp_lib_move_only_function should have the value 202110L in c++2b"
+# endif
 
 # ifndef __cpp_lib_not_fn
 #   error "__cpp_lib_not_fn should be defined in c++2b"
 # endif
 # if __cpp_lib_not_fn != 201603L
 #   error "__cpp_lib_not_fn should have the value 201603L in c++2b"
 # endif
 

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

 
 # ifndef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should be defined in c++2b"
 # endif
 # if __cpp_lib_memory_resource != 201603L
 #   error "__cpp_lib_memory_resource should have the value 201603L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_move_only_function
-#     error "__cpp_lib_move_only_function should be defined in c++2b"
-#   endif
-#   if __cpp_lib_move_only_function != 202110L
-#     error "__cpp_lib_move_only_function should have the value 202110L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_move_only_function
-#     error "__cpp_lib_move_only_function should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_move_only_function
+#   error "__cpp_lib_move_only_function should be defined in c++2b"
+# endif
+# if __cpp_lib_move_only_function != 202110L
+#   error "__cpp_lib_move_only_function should have the value 202110L in c++2b"
+# endif
 
 # ifndef __cpp_lib_node_extract
 #   error "__cpp_lib_node_extract should be defined in c++2b"
 # endif
 # if __cpp_lib_node_extract != 201606L
 #   error "__cpp_lib_node_extract should have the value 201606L in c++2b"
 # endif
 

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/functor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  static_assert(!std::is_nothrow_assignable_v<std::move_only_function<T>&, NonTrivial>);
+  {
+    std::move_only_function<T> f;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = &call_func);
+    assert(&ret == &f);
+    assert(f);
+  }
+  {
+    std::move_only_function<T> f;
+    decltype(&call_func) ptr                                     = nullptr;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = ptr);
+    assert(&ret == &f);
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = TriviallyDestructible{});
+    assert(&ret == &f);
+    assert(f);
+  }
+  {
+    std::move_only_function<T> f;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = TriviallyDestructibleTooLarge{});
+    assert(&ret == &f);
+    assert(f);
+  }
+  {
+    std::move_only_function<T> f;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = NonTrivial{});
+    assert(&ret == &f);
+    assert(f);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f = &S::func;
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(!f2);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+    test_member_function_pointer<T>();
+  });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  static_assert(!std::is_assignable_v<std::move_only_function<T>, int>);
+  {
+    std::move_only_function<T> f = &call_func;
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(!f);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(!f2);
+    LIBCPP_ASSERT(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(!f);
+  }
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(!f);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f = &S::func;
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(!f);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(!f2);
+    LIBCPP_ASSERT(!f);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+    test_member_function_pointer<T>();
+  });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move_other.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <utility>
+
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<void() const noexcept> f1;
+    std::move_only_function<T> f2;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+    assert(&ret == &f2);
+    assert(!f2);
+  }
+  {
+    std::move_only_function<void() const & noexcept> f1;
+    std::move_only_function<T> f2;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+    assert(&ret == &f2);
+    assert(!f2);
+  }
+}
+
+template <class T>
+void test2() {
+  {
+    std::move_only_function<int() const noexcept> f1 = [] noexcept { return 109; };
+    std::move_only_function<T> f2;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+    assert(&ret == &f2);
+    assert(f2);
+    assert(f2() == 109);
+  }
+  {
+    std::move_only_function<int() const& noexcept> f1 = [] noexcept { return 109; };
+    std::move_only_function<T> f2;
+    std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+    assert(&ret == &f2);
+    assert(f2);
+    assert(f2() == 109);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_lvalue_ref_qualified<int()>{}, []<class T> { test2<T>(); });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/nullptr.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<T> f = &call_func;
+    f                            = nullptr;
+    assert(!f);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    f                            = nullptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    f                            = nullptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    f                            = nullptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    f                            = nullptr;
+    assert(!f);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f = &S::func;
+    f                            = nullptr;
+    assert(!f);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    f                            = nullptr;
+    assert(!f);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+    test_member_function_pointer<T>();
+  });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() & {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() &>&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &>>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &> const&&>);
+
+void test() {
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S&)> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr              = nullptr;
+    std::move_only_function<void(S&)> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()&> f = CallTypeChecker{&type};
+    f();
+    assert(type == CallType::LValue);
+  }
+}
+
+void test_return() {
+  {
+    called                               = false;
+    std::move_only_function<int(int)&> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                               = false;
+    std::move_only_function<int(int)&> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                               = false;
+    std::move_only_function<int(int)&> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                               = false;
+    std::move_only_function<int(int)&> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() const& {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const&>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&> const&&>);
+
+void test() {
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(const S&)> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                    = nullptr;
+    std::move_only_function<void(const S&)> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() const&> f = CallTypeChecker{&type};
+    f();
+    assert(type == CallType::ConstLValue);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() const&> f = CallTypeChecker{&type};
+    f();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::as_const(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(std::as_const(f))();
+    assert(type == CallType::ConstLValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                     = false;
+    std::move_only_function<int(int) const&> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<int(int) const&> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<int(int) const&> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<int(int) const&> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const_noexcept.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() const& noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept> const&&>);
+
+void test() {
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(const S&) noexcept> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                             = nullptr;
+    std::move_only_function<void(const S&) noexcept> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() const& noexcept> f = CallTypeCheckerNoexcept{&type};
+    f();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::as_const(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(std::as_const(f))();
+    assert(type == CallType::ConstLValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                              = false;
+    std::move_only_function<int(int) const& noexcept> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                              = false;
+    std::move_only_function<int(int) const& noexcept> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                              = false;
+    std::move_only_function<int(int) const& noexcept> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                              = false;
+    std::move_only_function<int(int) const& noexcept> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_noexcept.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() & noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() & noexcept>&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept>>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept> const&&>);
+
+void test() {
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S&) noexcept> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                       = nullptr;
+    std::move_only_function<void(S&) noexcept> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()& noexcept> f = CallTypeCheckerNoexcept{&type};
+    f();
+    assert(type == CallType::LValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                        = false;
+    std::move_only_function<int(int)& noexcept> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                        = false;
+    std::move_only_function<int(int)& noexcept> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                        = false;
+    std::move_only_function<int(int)& noexcept> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                        = false;
+    std::move_only_function<int(int)& noexcept> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void()>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void()>>);
+static_assert(std::is_invocable_v<std::move_only_function<void()>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void()> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void()> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void()> const&&>);
+
+void test() {
+  {
+    called                            = false;
+    std::move_only_function<void()> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                            = false;
+    std::move_only_function<void()> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                            = false;
+    std::move_only_function<void()> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                            = false;
+    std::move_only_function<void()> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S)> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr             = nullptr;
+    std::move_only_function<void(S)> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()> f = CallTypeChecker{&type};
+    f();
+    assert(type == CallType::LValue);
+    type = CallType::None;
+    std::move(f)();
+    assert(type == CallType::LValue);
+  }
+}
+
+void test_return() {
+  {
+    called                              = false;
+    std::move_only_function<int(int)> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<int(int)> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<int(int)> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<int(int)> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() const noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const> const&&>);
+
+void test() {
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S) const> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                   = nullptr;
+    std::move_only_function<void(S) const> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() const> f = CallTypeChecker{&type};
+    f();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::as_const(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(std::as_const(f))();
+    assert(type == CallType::ConstLValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                    = false;
+    std::move_only_function<int(int) const> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<int(int) const> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<int(int) const> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<int(int) const> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const_noexcept.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() const noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept> const&&>);
+
+void test() {
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S) const noexcept> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                            = nullptr;
+    std::move_only_function<void(S) const noexcept> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() const noexcept> f = CallTypeCheckerNoexcept{&type};
+    f();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::as_const(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(f)();
+    assert(type == CallType::ConstLValue);
+    type = CallType::None;
+    std::move(std::as_const(f))();
+    assert(type == CallType::ConstLValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                             = false;
+    std::move_only_function<int(int) const noexcept> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<int(int) const noexcept> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<int(int) const noexcept> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<int(int) const noexcept> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_noexcept.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() noexcept> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() noexcept> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() noexcept> const&&>);
+
+void test() {
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = &call_func;
+    f();
+    assert(called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = TriviallyDestructible{};
+    f();
+    assert(called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S) noexcept> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                      = nullptr;
+    std::move_only_function<void(S) noexcept> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() noexcept> f = CallTypeCheckerNoexcept{&type};
+    f();
+    assert(type == CallType::LValue);
+    type = CallType::None;
+    std::move(f)();
+    assert(type == CallType::LValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                       = false;
+    std::move_only_function<int(int) noexcept> f = &get_val;
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<int(int) noexcept> f = TriviallyDestructible{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<int(int) noexcept> f = TriviallyDestructibleTooLarge{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<int(int) noexcept> f = NonTrivial{};
+    assert(f(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() && noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() &&>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() &&>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&> const&&>);
+
+void test() {
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = &call_func;
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = TriviallyDestructible{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = NonTrivial{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S)&&> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr               = nullptr;
+    std::move_only_function<void(S)&&> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()&&> f = CallTypeChecker{&type};
+    type                                = CallType::None;
+    std::move(f)();
+    assert(type == CallType::RValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                = false;
+    std::move_only_function<int(int)&&> f = &get_val;
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                = false;
+    std::move_only_function<int(int)&&> f = TriviallyDestructible{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                = false;
+    std::move_only_function<int(int)&&> f = TriviallyDestructibleTooLarge{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                = false;
+    std::move_only_function<int(int)&&> f = NonTrivial{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() const&& noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() const&&>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() const&&> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&> const&&>);
+
+void test() {
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = &call_func;
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = TriviallyDestructible{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = NonTrivial{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S) const&&> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                     = nullptr;
+    std::move_only_function<void(S) const&&> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() const&&> f = CallTypeChecker{&type};
+    type                                      = CallType::None;
+    std::move(f)();
+    assert(type == CallType::ConstRValue);
+    type = CallType::None;
+    std::move(std::as_const(f))();
+    assert(type == CallType::ConstRValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                      = false;
+    std::move_only_function<int(int) const&&> f = &get_val;
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<int(int) const&&> f = TriviallyDestructible{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<int(int) const&&> f = TriviallyDestructibleTooLarge{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<int(int) const&&> f = NonTrivial{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const_noexcept.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() const&& noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() const && noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() const && noexcept> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept> const&&>);
+
+void test() {
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = &call_func;
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = TriviallyDestructible{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = NonTrivial{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S) const&& noexcept> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                              = nullptr;
+    std::move_only_function<void(S) const&& noexcept> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void() const&& noexcept> f = CallTypeCheckerNoexcept{&type};
+    type                                               = CallType::None;
+    std::move(f)();
+    assert(type == CallType::ConstRValue);
+    type = CallType::None;
+    std::move(std::as_const(f))();
+    assert(type == CallType::ConstRValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                               = false;
+    std::move_only_function<int(int) const&& noexcept> f = &get_val;
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                               = false;
+    std::move_only_function<int(int) const&& noexcept> f = TriviallyDestructible{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                               = false;
+    std::move_only_function<int(int) const&& noexcept> f = TriviallyDestructibleTooLarge{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                               = false;
+    std::move_only_function<int(int) const&& noexcept> f = NonTrivial{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_noexcept.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+  void func() && noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() && noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() && noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept> const&&>);
+
+void test() {
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = &call_func;
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = TriviallyDestructible{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = NonTrivial{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S)&& noexcept> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr                        = nullptr;
+    std::move_only_function<void(S)&& noexcept> f = ptr;
+    assert(!f);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()&& noexcept> f = CallTypeCheckerNoexcept{&type};
+    type                                         = CallType::None;
+    std::move(f)();
+    assert(type == CallType::RValue);
+  }
+}
+
+void test_return() {
+  {
+    called                                         = false;
+    std::move_only_function<int(int)&& noexcept> f = &get_val;
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                         = false;
+    std::move_only_function<int(int)&& noexcept> f = TriviallyDestructible{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                         = false;
+    std::move_only_function<int(int)&& noexcept> f = TriviallyDestructibleTooLarge{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+  {
+    called                                         = false;
+    std::move_only_function<int(int)&& noexcept> f = NonTrivial{};
+    assert(std::move(f)(3) == 3);
+    assert(!called);
+  }
+}
+
+int main(int, char**) {
+  test();
+  test_return();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/common.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MOVE_ONLY_FUNCTION_COMMON_H
+#define MOVE_ONLY_FUNCTION_COMMON_H
+
+#include <initializer_list>
+#include <type_traits>
+
+inline bool called;
+inline void call_func() noexcept { called = true; }
+
+struct MoveCounter {
+  int* counter_;
+  MoveCounter(int* counter) : counter_(counter) {}
+  MoveCounter(MoveCounter&& other) : counter_(other.counter_) { ++*counter_; }
+};
+
+struct TriviallyDestructible {
+  TriviallyDestructible() = default;
+  TriviallyDestructible(MoveCounter) {}
+  TriviallyDestructible(std::initializer_list<int>, MoveCounter) {}
+  void operator()() const noexcept { called = true; }
+  int operator()(int i) const noexcept { return i; }
+};
+
+struct TriviallyDestructibleTooLarge {
+  TriviallyDestructibleTooLarge() = default;
+  TriviallyDestructibleTooLarge(MoveCounter) {}
+  TriviallyDestructibleTooLarge(std::initializer_list<int>, MoveCounter) {}
+  void operator()() const noexcept { called = true; }
+  int operator()(int i) const noexcept { return i; }
+  char a[5 * sizeof(void*)];
+};
+
+struct NonTrivial {
+  NonTrivial() = default;
+  NonTrivial(MoveCounter) {}
+  NonTrivial(std::initializer_list<int>&, MoveCounter) {}
+  NonTrivial(NonTrivial&&) noexcept(false) {}
+  ~NonTrivial() {}
+
+  void operator()() const noexcept { called = true; }
+  int operator()(int i) const noexcept { return i; }
+};
+
+inline int get_val(int i) noexcept { return i; }
+
+enum class CallType {
+  None,
+  LValue,
+  RValue,
+  ConstLValue,
+  ConstRValue,
+};
+
+struct CallTypeChecker {
+  CallType* type;
+  using enum CallType;
+  void operator()() & { *type = LValue; }
+  void operator()() && { *type = RValue; }
+  void operator()() const& { *type = ConstLValue; }
+  void operator()() const&& { *type = ConstRValue; }
+};
+
+struct CallTypeCheckerNoexcept {
+  CallType* type;
+  using enum CallType;
+  void operator()() & noexcept { *type = LValue; }
+  void operator()() && noexcept { *type = RValue; }
+  void operator()() const& noexcept { *type = ConstLValue; }
+  void operator()() const&& noexcept { *type = ConstRValue; }
+};
+
+#endif // MOVE_ONLY_FUNCTION_COMMON_H

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+
+template <class T>
+void test() {
+  std::move_only_function<T> f;
+  assert(!f);
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/functor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "count_new.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<T> f = &call_func;
+    assert(f);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    assert(f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    assert(f);
+  }
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    assert(f);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f = &S::func;
+    assert(f);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    assert(!f);
+  }
+}
+
+template <class T>
+void test_value_return_type() {
+  {
+    std::move_only_function<T> f = &get_val;
+    assert(f);
+  }
+  {
+    decltype(&get_val) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    assert(f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    assert(f);
+  }
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    assert(f);
+  }
+}
+
+template <class T>
+void test_throwing() {
+  struct ThrowingFunctor {
+    ThrowingFunctor() = default;
+    ThrowingFunctor(const ThrowingFunctor&) { throw 1; }
+    void operator()() {}
+  };
+  std::move_only_function<T> func({});
+}
+
+void check_new_delete_called() {
+  assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  assert(globalMemCounter.new_array_called == globalMemCounter.delete_array_called);
+  assert(globalMemCounter.aligned_new_called == globalMemCounter.aligned_delete_called);
+  assert(globalMemCounter.aligned_new_array_called == globalMemCounter.aligned_delete_array_called);
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+    test_member_function_pointer<T>();
+  });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test_value_return_type<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test_throwing<T>(); });
+  check_new_delete_called();
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructible>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleTooLarge>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<NonTrivial>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place_init_list.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructible>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleTooLarge>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<NonTrivial>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<T> f  = &call_func;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    decltype(&call_func) ptr      = nullptr;
+    std::move_only_function<T> f  = ptr;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(!f2);
+  }
+  {
+    std::move_only_function<T> f  = TriviallyDestructible{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    std::move_only_function<T> f  = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    std::move_only_function<T> f  = NonTrivial{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f  = &S::func;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    decltype(&S::func) ptr        = nullptr;
+    std::move_only_function<T> f  = ptr;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(!f2);
+  }
+}
+
+template <class T>
+void test_value() {
+  {
+    std::move_only_function<T> f  = &get_val;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    decltype(&get_val) ptr        = nullptr;
+    std::move_only_function<T> f  = ptr;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(!f2);
+  }
+  {
+    std::move_only_function<T> f  = TriviallyDestructible{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    std::move_only_function<T> f  = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+  {
+    std::move_only_function<T> f  = NonTrivial{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+    test_member_function_pointer<T>();
+  });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test_value<T>(); });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move_other.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "type_algorithms.h"
+
+static_assert(!std::is_constructible_v<std::move_only_function<void() const>, std::move_only_function<void()>>);
+static_assert(!std::is_constructible_v<std::move_only_function<void() noexcept>, std::move_only_function<void()>>);
+static_assert(
+    !std::is_constructible_v<std::move_only_function<void() const noexcept>, std::move_only_function<void()>>);
+static_assert(
+    !std::is_constructible_v<std::move_only_function<void() const noexcept>, std::move_only_function<void() const>>);
+static_assert(
+    !std::is_constructible_v<std::move_only_function<void() const noexcept>, std::move_only_function<void() noexcept>>);
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<void() const noexcept> f1;
+    std::move_only_function<T> f2 = std::move(f1);
+    assert(!f2);
+  }
+  {
+    std::move_only_function<void() const & noexcept> f1;
+    std::move_only_function<T> f2 = std::move(f1);
+    assert(!f2);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/nullptr.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+
+template <class T>
+void test() {
+  std::move_only_function<T> f = nullptr;
+  assert(!f);
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.adl.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+#include "common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<T> f = &call_func;
+    std::move_only_function<T> f2;
+    swap(f, f2);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    swap(f, f2);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+  }
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f = &S::func;
+    std::move_only_function<T> f2;
+    swap(f, f2);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    swap(f, f2);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+    test_member_function_pointer<T>();
+  });
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.member.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+#include "common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<T> f = &call_func;
+    std::move_only_function<T> f2;
+    f.swap(f2);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    f.swap(f2);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+  }
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f = &S::func;
+    std::move_only_function<T> f2;
+    f.swap(f2);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    f.swap(f2);
+  }
+}
+
+int main(int, char**) {
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+  meta::for_each(meta::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+    test_member_function_pointer<T>();
+  });
+
+  return 0;
+}

libcxx/test/support/count_new.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef COUNT_NEW_H
 #define COUNT_NEW_H
 
-# include <cstdlib>
+#include <algorithm>
 # include <cassert>
+# include <cstdlib>
 # include <new>
 
 #include "test_macros.h"
 
 #if defined(TEST_HAS_SANITIZERS)
 #define DISABLE_NEW_COUNT
 #endif
 

 
 void* operator new(std::size_t s, std::align_val_t av) TEST_THROW_SPEC(std::bad_alloc) {
   const std::size_t a = static_cast<std::size_t>(av);
   getGlobalMemCounter()->alignedNewCalled(s, a);
   void *ret;
 #ifdef USE_ALIGNED_ALLOC
   ret = _aligned_malloc(s, a);
 #else
-  posix_memalign(&ret, a, s);
+  // The alignment has to be a power of two and a multiple of sizeof(void*) for posix_memalign
+  // The power of two is required by the C++ standard, a multiple sizeof(void*) is only required for posix_memalign
+  posix_memalign(&ret, std::max(a, sizeof(void*)), s);
 #endif
   if (ret == nullptr)
     detail::throw_bad_alloc_helper();
   return ret;
 }
 
 void operator delete(void *p, std::align_val_t av) TEST_NOEXCEPT {
   const std::size_t a = static_cast<std::size_t>(av);

libcxx/test/support/type_algorithms.h

 #endif
               >;
 
 using integral_types = concatenate_t<character_types, signed_integer_types, unsigned_integer_types, type_list<bool> >;
 
 using floating_point_types = type_list<float, double, long double>;
 
 using arithmetic_types = concatenate_t<integral_types, floating_point_types>;
+
+template <class...>
+struct function_noexcept_const_lvalue_ref_qualified_impl;
+
+template <class ReturnT, class... Args>
+struct function_noexcept_const_lvalue_ref_qualified_impl<ReturnT(Args...)> {
+  using type =
+      type_list<ReturnT(Args...),
+                ReturnT(Args...)&,
+                ReturnT(Args...) noexcept,
+                ReturnT(Args...) & noexcept,
+                ReturnT(Args...) const,
+                ReturnT(Args...) const&,
+                ReturnT(Args...) const noexcept,
+                ReturnT(Args...) const & noexcept>;
+};
+
+template <class Func>
+using function_noexcept_const_lvalue_ref_qualified =
+    typename function_noexcept_const_lvalue_ref_qualified_impl<Func>::type;
+
+template <class...>
+struct function_noexcept_const_ref_qualified_impl;
+
+template <class ReturnT, class... Args>
+struct function_noexcept_const_ref_qualified_impl<ReturnT(Args...)> {
+  using type =
+      concatenate_t<function_noexcept_const_lvalue_ref_qualified<ReturnT(Args...)>,
+                    type_list<ReturnT(Args...)&&,
+                              ReturnT(Args...) && noexcept,
+                              ReturnT(Args...) const&&,
+                              ReturnT(Args...) const && noexcept> >;
+};
+
+template <class Func>
+using function_noexcept_const_ref_qualified = typename function_noexcept_const_ref_qualified_impl<Func>::type;
+
 } // namespace meta
 
 #endif // TEST_SUPPORT_TYPE_ALGORITHMS_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_memory_resource",
     "values": { "c++17": 201603 },
     "headers": ["memory_resource"],
   }, {
     "name": "__cpp_lib_move_only_function",
     "values": { "c++2b": 202110 },
     "headers": ["functional"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_node_extract",
     "values": { "c++17": 201606 },
     "headers": ["map", "set", "unordered_map", "unordered_set"],
   }, {
     "name": "__cpp_lib_nonmember_container_access",
     "values": { "c++17": 201411 },
     "headers": ["array", "deque", "forward_list", "iterator", "list", "map", "regex", "set", "string", "unordered_map", "unordered_set", "vector"],