[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

280

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_ = {}

294

redundant return before else?

360

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?

360

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)

365

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

203

__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...

297

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

203

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

297

nevermind - see other comment why this makes no sense

[lichray]

libcxx/include/__functional/move_only_function.h

26

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

libcxx/include/__functional/move_only_function_impl.h

70

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).

203

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

Exactly.

203

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.

267

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

359

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

83

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

26

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

70

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

359

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

127–128

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

26

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

70

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

127–128

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

libcxx/include/__functional/move_only_function.h

26

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

83

What are you talking about?

[ldionne]

libcxx/include/__functional/move_only_function.h

26

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

31 ↗

(On Diff #467116)

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

70

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

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{});
}

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.

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

9 ↗

(On Diff #479860)

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 ↗

(On Diff #479860)

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

75

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)>;

105

Can you use a more descriptive name here?

libcxx/.clang-format

 IndentWrappedFunctionNames: false
 IndentRequires: true
 InsertTrailingCommas: Wrapped
 KeepEmptyLinesAtTheStartOfBlocks: false
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: Inner
 PackConstructorInitializers: NextLine
 
-PenaltyIndentedWhitespace: 61
+PenaltyIndentedWhitespace: 2
 
 Language: Cpp
 Standard: c++20
 SpacesInAngles: Leave
 
 AlwaysBreakTemplateDeclarations: true
 PointerAlignment: Left
 

libcxx/docs/Status/Cxx2bPapers.csv

 "`P1425R4 <https://wg21.link/P1425R4>`__","LWG","Iterators pair constructors for stack and queue","June 2021","|Complete|","14.0"
 "`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","",""
 "`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"
 "`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_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
set(files
   __type_traits/is_trivially_constructible.h
   __type_traits/is_trivially_copy_assignable.h
   __type_traits/is_trivially_copy_constructible.h
   __type_traits/is_trivially_copyable.h
   __type_traits/is_trivially_default_constructible.h
   __type_traits/is_trivially_destructible.h
   __type_traits/is_trivially_move_assignable.h
   __type_traits/is_trivially_move_constructible.h
+  __type_traits/is_trivially_relocatable.h
   __type_traits/is_unbounded_array.h
   __type_traits/is_union.h
   __type_traits/is_unsigned.h
   __type_traits/is_unsigned_integer.h
   __type_traits/is_valid_expansion.h
   __type_traits/is_void.h
   __type_traits/is_volatile.h
   __type_traits/lazy.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_MOVE_ONLY_FUNCTION_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 > 20
+
+// 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
+
+#endif // _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_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 only partially guarded on purpose. This header is an implementation detail of move_only_function.h
+// and generates multiple versions of std::move_only_function
+
+#include <__bit/bit_cast.h>
+#include <__config>
+#include <__functional/invoke.h>
+#include <__memory/construct_at.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_trivially_relocatable.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <climits>
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <new>
+
+#include <cassert>
+
+#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___FUNCTIONAL_MOVE_ONLY_FUNCTION_IMPL_H
+#  define _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_IMPL_H
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// The storage for move_only_functions may be one of 3 things:
+// - A pointer to a heap object
+// - A trivially relocatable object
+// - A trivially relocatable object that also has a trivial destructor
+//
+// If the object is too large or not trivially relocatable it is stored on the heap.
+// (on 64-bit platforms) an object fits into the small buffer if
+// - it is trivially relocatable and has a size of less than 32 bytes and an alignment of no more than 8 bytes, or
+// - it is trivially destructible and has a size of less than 40 bytes and an alignment of no more than 8 bytes.
+//
+// "size of" in this case doesn't mean "sizeof". Objects which have padding bytes at the end may also be put into
+// the small buffer if the padding byte can be detected by [[no_unique_address]]. For example
+//
+//   class [[clang::trivial_abi]] A {
+//     int* begin;
+//     int* end;
+//     int* cap;
+//     int flags;
+//   public:
+//     A(A&&);
+//     ~A();
+//     void operator()() {}
+//   };
+//
+// is put into the small buffer, even though sizeof(A) == 32.
+
+union __move_only_function_storage {
+  using _DestroyFn = void(void*);
+  using _CallFn    = void;
+
+  static constexpr auto __target_size = 6 * sizeof(void*);
+
+  enum class _Status : uint8_t {
+    _NotEngaged,
+    _TriviallyRelocatable,
+    _TriviallyDestructible,
+    _Heap,
+  };
+
+  struct _HeapObject {
+    _CallFn* __call_;
+    _DestroyFn* __destroy_;
+    std::byte* __heap_;
+    std::byte __padding_[__target_size - 3 * sizeof(void*) - 1];
+    _Status __status_;
+  } __large_;
+  static_assert(sizeof(_HeapObject) == __target_size);
+  static_assert(offsetof(_HeapObject, __status_) == __target_size - 1);
+
+  struct _TriviallyRelocatableObject {
+    _CallFn* __call_;
+    _DestroyFn* __destroy_;
+    alignas(void*) std::byte __data_[__target_size - 2 * sizeof(void*) - 1];
+    _Status __status_;
+  } __trivially_relocatable_;
+  static_assert(sizeof(_TriviallyRelocatableObject) == __target_size);
+  static_assert(offsetof(_TriviallyRelocatableObject, __status_) == __target_size - 1);
+
+  struct _TriviallyDestructibleObject {
+    _CallFn* __call_;
+    alignas(void*) std::byte __data_[__target_size - 1 * sizeof(void*) - 1];
+    _Status __status_;
+  } __trivially_destructible_;
+  static_assert(sizeof(_TriviallyDestructibleObject) == __target_size);
+  static_assert(offsetof(_TriviallyDestructibleObject, __status_) == __target_size - 1);
+
+private:
+  // try to squeeze in another char to see if we can use the last byte for our own purposes
+  template <class _Func>
+  struct _Compact {
+    _LIBCPP_NO_UNIQUE_ADDRESS _Func __func;
+    char __c;
+  };
+
+  template <class _Func, size_t _BufferSize, size_t BufferAlignment>
+  static constexpr bool __fits_in_buffer =
+      sizeof(_Compact<_Func>) <= _BufferSize + 1 && alignof(_Func) <= BufferAlignment;
+
+  template <class _Func>
+  static constexpr bool __fits_in_trivially_relocatable_buffer_impl =
+      __libcpp_is_trivially_relocatable_v<_Func> &&
+      __fits_in_buffer<_Func,
+                       sizeof(_TriviallyRelocatableObject::__data_),
+                       alignof(_TriviallyRelocatableObject::__data_)>;
+
+  template <class _Func>
+  static constexpr bool __fits_in_trivially_destructible_buffer_impl =
+      __libcpp_is_trivially_relocatable_v<_Func> && is_trivially_destructible_v<_Func> &&
+      __fits_in_buffer<_Func,
+                       sizeof(_TriviallyDestructibleObject::__data_),
+                       alignof(_TriviallyDestructibleObject::__data_)>;
+
+public:
+  template <class _Func>
+  static constexpr bool __fits_in_trivially_relocatable_buffer =
+      __fits_in_trivially_relocatable_buffer_impl<remove_cvref_t<_Func>>;
+
+  template <class _Func>
+  static constexpr bool __fits_in_trivially_destructible_buffer =
+      __fits_in_trivially_destructible_buffer_impl<remove_cvref_t<_Func>>;
+};
+
+static_assert(alignof(__move_only_function_storage) == alignof(void*));
+static_assert(sizeof(__move_only_function_storage) == __move_only_function_storage::__target_size);
+
+template <class...>
+class move_only_function;
+
+template <class...>
+struct __is_move_only_function : false_type {};
+
+template <class _ReturnT, class... _ArgTypes>
+struct __is_move_only_function<move_only_function<_ReturnT(_ArgTypes...)>> : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+// This header is only partially guarded on purpose. This header is an implementation detail of move_only_function.h
+// and generates multiple versions of std::move_only_function
+#endif // _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_IMPL_H
+
+#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_INV_QUALS _LIBCPP_MOVE_ONLY_FUNCTION_CV&
+#else
+#  define _LIBCPP_MOVE_ONLY_FUNCTION_INV_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_CV_REF _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 _ReturnT, class... _ArgTypes>
+class _LIBCPP_MOVE_ONLY_FUNCTION_TRIVIAL_ABI move_only_function<_ReturnT(
+    _ArgTypes...) _LIBCPP_MOVE_ONLY_FUNCTION_CV_REF noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT)> {
+  using _Store = __move_only_function_storage;
+
+  template <class _Functor>
+  struct __function_wrappers_impl {
+    __function_wrappers_impl() = delete;
+    __function_wrappers_impl(const __function_wrappers_impl&) = delete;
+    __function_wrappers_impl(__function_wrappers_impl&&)      = delete;
+
+    _LIBCPP_HIDE_FROM_ABI static void __destroy(void* __store) noexcept {
+      std::destroy_at(static_cast<_Functor*>(__store));
+    }
+
+    _LIBCPP_HIDE_FROM_ABI static _ReturnT
+    __call(void* __functor, _ArgTypes&&... __args) noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
+      return std::invoke(static_cast<_Functor _LIBCPP_MOVE_ONLY_FUNCTION_INV_QUALS>(*static_cast<_Functor*>(__functor)),
+                         std::forward<_ArgTypes>(__args)...);
+    }
+  };
+
+  template <class _Functor>
+  using __function_wrappers = __function_wrappers_impl<remove_cvref_t<_Functor>>;
+
+  template <class _VT>
+  consteval static bool __is_callable_from_impl() {
+    if (_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
+      return is_nothrow_invocable_r_v< _ReturnT, _VT _LIBCPP_MOVE_ONLY_FUNCTION_CV_REF, _ArgTypes...> &&
+             is_nothrow_invocable_r_v<_ReturnT, _VT _LIBCPP_MOVE_ONLY_FUNCTION_INV_QUALS, _ArgTypes...>;
+    } else {
+      return is_invocable_r_v<_ReturnT, _VT _LIBCPP_MOVE_ONLY_FUNCTION_CV_REF, _ArgTypes...> &&
+             is_invocable_r_v<_ReturnT, _VT _LIBCPP_MOVE_ONLY_FUNCTION_INV_QUALS, _ArgTypes...>;
+    }
+    return false;
+  }
+
+  template <class _VT>
+  static constexpr bool __is_callable_from = __is_callable_from_impl<decay_t<_VT>>();
+
+  template <class _Func, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void __construct(_Args&&... __args) {
+    static_assert(is_constructible_v<decay_t<_Func>, _Func>);
+
+    using _FuncWraps = __function_wrappers<_Func>;
+    using _UnRefFunc = remove_reference_t<_Func>;
+
+    if constexpr (_Store::__fits_in_trivially_destructible_buffer<_Func>) {
+      auto& __data   = __storage_.__trivially_destructible_;
+      __data.__call_ = std::bit_cast<void*>(&_FuncWraps::__call);
+      std::construct_at(reinterpret_cast<_UnRefFunc*>(__data.__data_), std::forward<_Args>(__args)...);
+      __data.__status_ = _Store::_Status::_TriviallyDestructible;
+    } else if constexpr (_Store::__fits_in_trivially_relocatable_buffer<_Func>) {
+      auto& __data      = __storage_.__trivially_relocatable_;
+      __data.__call_    = std::bit_cast<void*>(&_FuncWraps::__call);
+      __data.__destroy_ = &_FuncWraps::__destroy;
+      std::construct_at(reinterpret_cast<_UnRefFunc*>(__data.__data_), std::forward<_Args>(__args)...);
+      __data.__status_ = _Store::_Status::_TriviallyRelocatable;
+    } else {
+      auto& __data      = __storage_.__large_;
+      __data.__call_    = std::bit_cast<void*>(&_FuncWraps::__call);
+      __data.__destroy_ = &_FuncWraps::__destroy;
+      __data.__heap_    = static_cast<std::byte*>(::operator new(sizeof(_Func), std::align_val_t(alignof(_Func))));
+      std::construct_at(reinterpret_cast<_UnRefFunc*>(__data.__heap_), std::forward<_Args>(__args)...);
+      __data.__status_ = _Store::_Status::_Heap;
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __reset() {
+    using enum _Store::_Status;
+    switch (__storage_.__large_.__status_) {
+    case _NotEngaged:
+    case _TriviallyDestructible:
+      break;
+
+    case _TriviallyRelocatable:
+      __storage_.__trivially_relocatable_.__destroy_(&__storage_.__trivially_relocatable_.__data_);
+      break;
+    case _Heap:
+      __storage_.__large_.__destroy_(__storage_.__large_.__heap_);
+      ::operator delete(__storage_.__large_.__heap_);
+      break;
+    }
+    __storage_.__large_.__status_ = _NotEngaged;
+  }
+
+public:
+  using result_type = _ReturnT;
+
+  // [func.wrap.move.ctor]
+  move_only_function() noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI move_only_function(nullptr_t) noexcept : __storage_({}) {}
+  _LIBCPP_HIDE_FROM_ABI move_only_function(move_only_function&& __other) noexcept : __storage_(__other.__storage_) {
+    __other.__storage_ = {};
+  }
+
+  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 _FuncWraps = __function_wrappers<_Func>;
+    using _UnRefFunc = remove_reference_t<_Func>;
+
+    if constexpr ((is_pointer_v<_UnRefFunc> && is_function_v<remove_pointer_t<_UnRefFunc>>) ||
+                  is_member_function_pointer_v<_UnRefFunc>) {
+      if (__func == nullptr) {
+        __storage_ = {};
+        return;
+      } else {
+        auto& __data   = __storage_.__trivially_destructible_;
+        __data.__call_ = std::bit_cast<void*>(&_FuncWraps::__call);
+        std::construct_at(reinterpret_cast<_UnRefFunc*>(__data.__data_), std::forward<_Func>(__func));
+        __data.__status_ = _Store::_Status::_TriviallyDestructible;
+      }
+    } else if constexpr (__is_move_only_function<remove_cvref_t<_Func>>::value) {
+      if (!__func) {
+        __storage_ = {};
+      } else {
+        auto& __data      = __storage_.__large_;
+        __data.__call_    = std::bit_cast<void*>(&_FuncWraps::__call);
+        __data.__destroy_ = &_FuncWraps::__destroy;
+        __data.__heap_    = static_cast<std::byte*>(::operator new(sizeof(_Func), std::align_val_t(alignof(_Func))));
+        std::construct_at(reinterpret_cast<_UnRefFunc*>(__data.__heap_), std::forward<_Func>(__func));
+        __data.__status_ = _Store::_Status::_Heap;
+      }
+    } else {
+      __construct<_Func>(std::forward<_Func>(__func));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Store::_Status __get_status() noexcept { return __storage_.__large_.__status_; }
+
+  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) {
+    __construct<_Func>(__il, std::forward<_Args>(__args)...);
+  }
+
+  // TODO: Do we want to make this `noexcept` as an extensions?
+  _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;
+  }
+
+  // TODO: Do we want to make this `noexcept` as an extensions?
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI move_only_function& operator=(_Func&& __func) noexcept {
+    move_only_function(std::forward<_Func>(__func)).swap(*this);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~move_only_function() { __reset(); }
+
+  // [func.wrap.move.inv]
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept {
+    return __storage_.__large_.__status_ != _Store::_Status::_NotEngaged;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _ReturnT operator()(_ArgTypes... __args) _LIBCPP_MOVE_ONLY_FUNCTION_CV_REF
+      noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
+    auto __call = [&](auto&& __callable, auto&& __data) {
+      return std::bit_cast<void (*)(_LIBCPP_MOVE_ONLY_FUNCTION_CV void*, _ArgTypes...)>(__callable)(
+          __data, std::forward<_ArgTypes>(__args)...);
+    };
+
+    using enum _Store::_Status;
+    switch (__storage_.__large_.__status_) {
+    case _NotEngaged:
+      _LIBCPP_ASSERT(false, "Tried to call move_only_function which doesn't hold a callable object");
+    case _TriviallyDestructible:
+      return __call(__storage_.__trivially_destructible_.__call_, &__storage_.__trivially_destructible_.__data_);
+    case _TriviallyRelocatable:
+      return __call(__storage_.__trivially_relocatable_.__call_, &__storage_.__trivially_relocatable_.__data_);
+    case _Heap:
+      return __call(__storage_.__large_.__call_, &__storage_.__large_.__heap_);
+    }
+  }
+
+  // [func.wrap.move.util]
+  _LIBCPP_HIDE_FROM_ABI void swap(move_only_function& __other) noexcept { std::swap(__storage_, __other.__storage_); }
+
+  _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:
+  _Store __storage_ = {};
+};
+
+template <class _ReturnT, class... _Args>
+struct __libcpp_is_trivially_relocatable<move_only_function<_ReturnT(
+    _Args...) _LIBCPP_MOVE_ONLY_FUNCTION_CV_REF noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT)>> : true_type {};
+
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_CV
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_REF
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_INV_QUALS
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_CV_REF
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/include/__type_traits/is_trivially_relocatable.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___TYPE_TRAITS_IS_TRIVIALLY_RELOCATABLE_H
+#define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_RELOCATABLE_H
+
+#include <__config>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/is_trivially_move_constructible.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+//------------------------------------------------------WARNING-------------------------------------------------------//
+//
+// This type trait should only be used where ABI stability isn't relevant or can be assured by other means,
+// like in function bodies or where the difference can be detected at runtime. If this trait is used in ABI-sensitive
+// environments it has to be ensured that Clang and GCC can interpret the data produced by each other. If you are not
+// certain that this is the case DO NOT USE THIS TYPE TRAIT
+//
+//--------------------------------------------------------------------------------------------------------------------//
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if __has_builtin(__is_trivially_relocatable)
+
+template <class _Type>
+struct __libcpp_is_trivially_relocatable : integral_constant<bool, __is_trivially_relocatable(_Type)> {};
+
+#else
+
+template <class _Type>
+using __libcpp_is_trivially_relocatable =
+    integral_constant<bool, is_trivially_move_constructible<_Type>::value && is_trivially_destructible_v<_Type>::value>;
+
+#endif // __has_builtin(__is_trivially_relocatable)
+
+#if _LIBCPP_STD_VER > 14
+template <class _Type>
+constexpr bool __libcpp_is_trivially_relocatable_v = __libcpp_is_trivially_relocatable<_Type>::value;
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_RELOCATABLE_H

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/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 "test_macros.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<T> f = &call_func;
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    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.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleSqueezeFit{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    std::move_only_function<T> f = TriviallyRelocatable{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableSqueezeFit{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableTooLarge{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#endif
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    std::move_only_function<T> f2;
+    f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+}
+
+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.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    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.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+  call_test<void(S)>([]<class T> { test_member_function_pointer<T>(); });
+}

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 "test_macros.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 = TriviallyDestructibleSqueezeFit{};
+    f = nullptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    f = nullptr;
+    assert(!f);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    std::move_only_function<T> f = TriviallyRelocatable{};
+    f = nullptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableSqueezeFit{};
+    f = nullptr;
+    assert(!f);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableTooLarge{};
+    f = nullptr;
+    assert(!f);
+  }
+#endif
+  {
+    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**) {
+  call_test<void()>([]<class T> { test<T>(); });
+  call_test<void(S)>([]<class T> { test_member_function_pointer<T>(); });
+}

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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    called                             = false;
+    std::move_only_function<void()&> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S&)> f = &S::func;
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr              = nullptr;
+    std::move_only_function<void(S&)> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()&> f = CallTypeChecker{&type};
+    f();
+    assert(type == CallType::LValue);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                   = false;
+    std::move_only_function<void() const&> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                    = nullptr;
+    std::move_only_function<void(const S&)> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 <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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                            = false;
+    std::move_only_function<void() const& noexcept> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                             = nullptr;
+    std::move_only_function<void(const S&) noexcept> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                      = false;
+    std::move_only_function<void()& noexcept> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                       = nullptr;
+    std::move_only_function<void(S&) noexcept> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()& noexcept> f = CallTypeCheckerNoexcept{&type};
+    f();
+    assert(type == CallType::LValue);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                            = false;
+    std::move_only_function<void()> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                            = false;
+    std::move_only_function<void()> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                            = false;
+    std::move_only_function<void()> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                            = false;
+    std::move_only_function<void()> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    called                            = false;
+    std::move_only_function<void()> f = NonTrivial{};
+    f();
+    assert(called);
+  }
+  {
+    std::move_only_function<void(S)> f = &S::func;
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr             = nullptr;
+    std::move_only_function<void(S)> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                  = false;
+    std::move_only_function<void() const> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                   = nullptr;
+    std::move_only_function<void(S) const> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                           = false;
+    std::move_only_function<void() const noexcept> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                            = nullptr;
+    std::move_only_function<void(S) const noexcept> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 "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 = TriviallyDestructibleSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = TriviallyDestructibleTooLarge{};
+    f();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = TriviallyRelocatable{};
+    f();
+    assert(called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = TriviallyRelocatableSqueezeFit{};
+    f();
+    assert(called);
+  }
+  {
+    called                                     = false;
+    std::move_only_function<void() noexcept> f = TriviallyRelocatableTooLarge{};
+    f();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                      = nullptr;
+    std::move_only_function<void(S) noexcept> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 "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 = TriviallyDestructibleSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = TriviallyRelocatable{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = TriviallyRelocatableSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                              = false;
+    std::move_only_function<void()&&> f = TriviallyRelocatableTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr               = nullptr;
+    std::move_only_function<void(S)&&> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()&&> f = CallTypeChecker{&type};
+    type                                = CallType::None;
+    std::move(f)();
+    assert(type == CallType::RValue);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = TriviallyRelocatable{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = TriviallyRelocatableSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                    = false;
+    std::move_only_function<void() const&&> f = TriviallyRelocatableTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                     = nullptr;
+    std::move_only_function<void(S) const&&> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = TriviallyRelocatable{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = TriviallyRelocatableSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                             = false;
+    std::move_only_function<void() const&& noexcept> f = TriviallyRelocatableTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                              = nullptr;
+    std::move_only_function<void(S) const&& noexcept> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    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);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 = TriviallyDestructibleSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = TriviallyDestructibleTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = TriviallyRelocatable{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = TriviallyRelocatableSqueezeFit{};
+    std::move(f)();
+    assert(called);
+  }
+  {
+    called                                       = false;
+    std::move_only_function<void()&& noexcept> f = TriviallyRelocatableTooLarge{};
+    std::move(f)();
+    assert(called);
+  }
+#endif
+  {
+    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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr                        = nullptr;
+    std::move_only_function<void(S)&& noexcept> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    CallType type;
+    std::move_only_function<void()&& noexcept> f = CallTypeCheckerNoexcept{&type};
+    type                                         = CallType::None;
+    std::move(f)();
+    assert(type == CallType::RValue);
+  }
+}
+
+int main(int, char**) {
+  test();
+
+  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 "test_macros.h"
+
+inline bool called;
+inline void call_func() noexcept { called = true; }
+
+template <class...>
+struct call_test_impl;
+
+template <class ReturnT, class Functor, class... Args>
+struct call_test_impl<ReturnT(Args...), Functor> {
+  call_test_impl(Functor func) {
+    func.template operator()<ReturnT(Args...)>();
+    func.template operator()<ReturnT(Args...)&>();
+    func.template operator()<ReturnT(Args...) &&>();
+    func.template operator()<ReturnT(Args...) noexcept>();
+    func.template operator()<ReturnT(Args...) & noexcept>();
+    func.template operator()<ReturnT(Args...) && noexcept>();
+    func.template operator()<ReturnT(Args...) const>();
+    func.template operator()<ReturnT(Args...) const&>();
+    func.template operator()<ReturnT(Args...) const&&>();
+    func.template operator()<ReturnT(Args...) const noexcept>();
+    func.template operator()<ReturnT(Args...) const & noexcept>();
+    func.template operator()<ReturnT(Args...) const && noexcept>();
+  }
+};
+
+template <class FuncT, class Functor>
+void call_test(Functor f) {
+  call_test_impl<FuncT, Functor>{f};
+}
+
+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; }
+};
+
+struct TriviallyDestructibleSqueezeFit {
+  TriviallyDestructibleSqueezeFit() = default;
+  TriviallyDestructibleSqueezeFit(MoveCounter) {}
+  TriviallyDestructibleSqueezeFit(std::initializer_list<int>, MoveCounter) {}
+  void operator()() const noexcept { called = true; }
+
+private:
+  [[maybe_unused]] void* ptr;
+  [[maybe_unused]] char a[4 * sizeof(void*) - 1];
+};
+
+struct TriviallyDestructibleTooLarge {
+  TriviallyDestructibleTooLarge() = default;
+  TriviallyDestructibleTooLarge(MoveCounter) {}
+  TriviallyDestructibleTooLarge(std::initializer_list<int>, MoveCounter) {}
+  void operator()() const noexcept { called = true; }
+  char a[5 * sizeof(void*)];
+};
+
+#ifdef TEST_COMPILER_CLANG
+struct [[clang::trivial_abi]] TriviallyRelocatable {
+  TriviallyRelocatable() = default;
+  TriviallyRelocatable(MoveCounter) {}
+  TriviallyRelocatable(std::initializer_list<int>, MoveCounter) {}
+  TriviallyRelocatable(TriviallyRelocatable&&) {}
+  ~TriviallyRelocatable() {}
+
+  void operator()() const noexcept { called = true; }
+};
+
+struct [[clang::trivial_abi]] TriviallyRelocatableSqueezeFit {
+  TriviallyRelocatableSqueezeFit() = default;
+  TriviallyRelocatableSqueezeFit(MoveCounter) {}
+  TriviallyRelocatableSqueezeFit(std::initializer_list<int>, MoveCounter) {}
+  TriviallyRelocatableSqueezeFit(TriviallyRelocatableSqueezeFit&&) {}
+  ~TriviallyRelocatableSqueezeFit() {}
+
+  void operator()() const noexcept { called = true; }
+
+private:
+  [[maybe_unused]] void* ptr;
+  [[maybe_unused]] char a[3 * sizeof(void*) - 1];
+};
+
+struct [[clang::trivial_abi]] TriviallyRelocatableTooLarge {
+  TriviallyRelocatableTooLarge() = default;
+  TriviallyRelocatableTooLarge(MoveCounter) {}
+  TriviallyRelocatableTooLarge(std::initializer_list<int>, MoveCounter) {}
+  ~TriviallyRelocatableTooLarge() {}
+
+  void operator()() const noexcept { called = true; }
+
+private:
+  [[maybe_unused]] char a[4 * sizeof(void*)];
+};
+#endif
+
+struct NonTrivial {
+  NonTrivial() = default;
+  NonTrivial(MoveCounter) {}
+  NonTrivial(std::initializer_list<int>, MoveCounter) {}
+  NonTrivial(NonTrivial&&) {}
+  ~NonTrivial() {}
+
+  void operator()() const noexcept { called = true; }
+};
+
+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 "../common.h"
+
+template <class T>
+void test() {
+  std::move_only_function<T> f;
+  assert(!f);
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+}

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 "test_macros.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+  {
+    std::move_only_function<T> f = &call_func;
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleSqueezeFit{};
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    std::move_only_function<T> f = TriviallyRelocatable{};
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableSqueezeFit{};
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableTooLarge{};
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#endif
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+}
+
+struct S {
+  void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+  {
+    std::move_only_function<T> f = &S::func;
+    assert(f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    assert(!f);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+  call_test<void(S)>([]<class T> { test_member_function_pointer<T>(); });
+}

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 "test_macros.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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleSqueezeFit>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleTooLarge>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyRelocatable>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyRelocatableSqueezeFit>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyRelocatableTooLarge>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#endif
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<NonTrivial>, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+}

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 "test_macros.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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleSqueezeFit>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleTooLarge>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyRelocatable>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyRelocatableSqueezeFit>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<TriviallyRelocatableTooLarge>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#endif
+  {
+    int counter = 0;
+    std::move_only_function<T> f{std::in_place_type<NonTrivial>, {1}, MoveCounter{&counter}};
+    assert(f);
+    assert(counter == 1);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+}

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 "test_macros.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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(!f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleSqueezeFit{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    std::move_only_function<T> f = TriviallyRelocatable{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableSqueezeFit{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableTooLarge{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#endif
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    std::move_only_function<T> f2 = std::move(f);
+    assert(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+}
+
+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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2 = std::move(f);
+    assert(!f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+  call_test<void(S)>([]<class T> { test_member_function_pointer<T>(); });
+}

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 "../common.h"
+
+template <class T>
+void test() {
+  std::move_only_function<T> f = nullptr;
+  assert(!f);
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+}

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 "test_macros.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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleSqueezeFit{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    std::move_only_function<T> f = TriviallyRelocatable{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableSqueezeFit{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableTooLarge{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#endif
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleSqueezeFit{};
+    std::move_only_function<T> f2 = NonTrivial{};
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+}
+
+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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    swap(f, f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+  call_test<void(S)>([]<class T> { test_member_function_pointer<T>(); });
+}

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 "test_macros.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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&call_func) ptr     = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructible{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleSqueezeFit{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#ifdef TEST_COMPILER_CLANG
+  {
+    std::move_only_function<T> f = TriviallyRelocatable{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableSqueezeFit{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyRelocatable);
+  }
+  {
+    std::move_only_function<T> f = TriviallyRelocatableTooLarge{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+#endif
+  {
+    std::move_only_function<T> f = NonTrivial{};
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+  }
+  {
+    std::move_only_function<T> f = TriviallyDestructibleSqueezeFit{};
+    std::move_only_function<T> f2 = NonTrivial{};
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_Heap);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+}
+
+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);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_TriviallyDestructible);
+  }
+  {
+    decltype(&S::func) ptr       = nullptr;
+    std::move_only_function<T> f = ptr;
+    std::move_only_function<T> f2;
+    f.swap(f2);
+    LIBCPP_ASSERT(f.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+    LIBCPP_ASSERT(f2.__get_status() == std::__move_only_function_storage::_Status::_NotEngaged);
+  }
+}
+
+int main(int, char**) {
+  call_test<void()>([]<class T> { test<T>(); });
+  call_test<void(S)>([]<class T> { test_member_function_pointer<T>(); });
+}