[libcxx-commits] [libcxx] [libc++] Implement std::move_only_function (P0288R9) (PR #94670)
Nikolas Klauser via libcxx-commits
libcxx-commits at lists.llvm.org
Thu Jun 6 12:36:18 PDT 2024
https://github.com/philnik777 created https://github.com/llvm/llvm-project/pull/94670
- [libc++] Add __pointer_int_pair
- [libc++] Implement P0288R9 (move_only_function)
>From 98c61df87ff321e6f7d7800a788e28f7b7e8cff7 Mon Sep 17 00:00:00 2001
From: Nikolas Klauser <nikolasklauser at berlin.de>
Date: Tue, 4 Jun 2024 09:04:47 +0200
Subject: [PATCH 1/2] [libc++] Add __pointer_int_pair
---
libcxx/include/CMakeLists.txt | 1 +
libcxx/include/__utility/pointer_int_pair.h | 154 ++++++++++++++++++
libcxx/include/module.modulemap | 1 +
.../assert.constructor.pass.cpp | 44 +++++
.../pointer_int_pair/constinit.verify.cpp | 21 +++
.../pointer_int_pair.pass.cpp | 104 ++++++++++++
.../static_asserts.verify.cpp | 23 +++
7 files changed, 348 insertions(+)
create mode 100644 libcxx/include/__utility/pointer_int_pair.h
create mode 100644 libcxx/test/libcxx/utilities/pointer_int_pair/assert.constructor.pass.cpp
create mode 100644 libcxx/test/libcxx/utilities/pointer_int_pair/constinit.verify.cpp
create mode 100644 libcxx/test/libcxx/utilities/pointer_int_pair/pointer_int_pair.pass.cpp
create mode 100644 libcxx/test/libcxx/utilities/pointer_int_pair/static_asserts.verify.cpp
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index cfe1f44777bca..289baf2338256 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -857,6 +857,7 @@ set(files
__utility/no_destroy.h
__utility/pair.h
__utility/piecewise_construct.h
+ __utility/pointer_int_pair.h
__utility/priority_tag.h
__utility/private_constructor_tag.h
__utility/rel_ops.h
diff --git a/libcxx/include/__utility/pointer_int_pair.h b/libcxx/include/__utility/pointer_int_pair.h
new file mode 100644
index 0000000000000..9c64b023c60e6
--- /dev/null
+++ b/libcxx/include/__utility/pointer_int_pair.h
@@ -0,0 +1,154 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___UTILITY_POINTER_INT_PAIR_H
+#define _LIBCPP___UTILITY_POINTER_INT_PAIR_H
+
+#include <__assert>
+#include <__bit/bit_log2.h>
+#include <__concepts/derived_from.h>
+#include <__config>
+#include <__tuple/tuple_element.h>
+#include <__tuple/tuple_size.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_unsigned.h>
+#include <__type_traits/is_void.h>
+#include <__type_traits/remove_pointer.h>
+#include <__utility/swap.h>
+#include <cstddef>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+// A __pointer_int_pair is a pair of a pointer and an integral type. The lower bits of the pointer that are free
+// due to the alignment requirement of the pointee are used to store the integral type.
+//
+// This imposes a constraint on the number of bits available for the integral type -- the integral type can use
+// at most log2(alignof(T)) bits. This technique allows storing the integral type without additional storage
+// beyond that of the pointer itself, at the cost of some bit twiddling.
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class>
+struct _PointerLikeTraits;
+
+template <class _Tp>
+ requires(!is_void_v<_Tp>)
+struct _PointerLikeTraits<_Tp*> {
+ static constexpr size_t __low_bits_available = std::__bit_log2(alignof(_Tp));
+
+ static _LIBCPP_HIDE_FROM_ABI uintptr_t __to_uintptr(_Tp* __ptr) { return reinterpret_cast<uintptr_t>(__ptr); }
+ static _LIBCPP_HIDE_FROM_ABI _Tp* __to_pointer(uintptr_t __ptr) { return reinterpret_cast<_Tp*>(__ptr); }
+};
+
+template <class _Tp>
+ requires is_void_v<_Tp>
+struct _PointerLikeTraits<_Tp*> {
+ static constexpr size_t __low_bits_available = 0;
+
+ static _LIBCPP_HIDE_FROM_ABI uintptr_t __to_uintptr(_Tp* __ptr) { return reinterpret_cast<uintptr_t>(__ptr); }
+ static _LIBCPP_HIDE_FROM_ABI _Tp* __to_pointer(uintptr_t __ptr) { return reinterpret_cast<_Tp*>(__ptr); }
+};
+
+enum class __integer_width : size_t {};
+
+template <class _Pointer, class _IntType, __integer_width __int_bit_count>
+class __pointer_int_pair {
+ using _PointerTraits = _PointerLikeTraits<_Pointer>;
+
+ static constexpr auto __int_width = static_cast<size_t>(__int_bit_count);
+
+ static_assert(__int_width <= _PointerTraits::__low_bits_available,
+ "Not enough bits available for requested bit count");
+ static_assert(is_integral_v<_IntType>, "_IntType has to be an integral type");
+ static_assert(is_unsigned_v<_IntType>, "__pointer_int_pair doesn't work for signed types");
+
+ static constexpr size_t __extra_bits = _PointerTraits::__low_bits_available - __int_width;
+ static constexpr uintptr_t __int_mask = static_cast<uintptr_t>(1 << _PointerTraits::__low_bits_available) - 1;
+ static constexpr uintptr_t __ptr_mask = ~__int_mask;
+
+ uintptr_t __value_ = 0;
+
+public:
+ __pointer_int_pair() = default;
+ __pointer_int_pair(const __pointer_int_pair&) = default;
+ __pointer_int_pair(__pointer_int_pair&&) = default;
+ __pointer_int_pair& operator=(const __pointer_int_pair&) = default;
+ __pointer_int_pair& operator=(__pointer_int_pair&&) = default;
+ ~__pointer_int_pair() = default;
+
+ _LIBCPP_HIDE_FROM_ABI __pointer_int_pair(_Pointer __ptr_value, _IntType __int_value)
+ : __value_(_PointerTraits::__to_uintptr(__ptr_value) | (__int_value << __extra_bits)) {
+ _LIBCPP_ASSERT_INTERNAL((__int_value & (__int_mask >> __extra_bits)) == __int_value, "integer is too large!");
+ _LIBCPP_ASSERT_INTERNAL(
+ (_PointerTraits::__to_uintptr(__ptr_value) & __ptr_mask) == _PointerTraits::__to_uintptr(__ptr_value),
+ "Pointer alignment is too low!");
+ }
+
+ _LIBCPP_HIDE_FROM_ABI _IntType __get_value() const { return (__value_ & __int_mask) >> __extra_bits; }
+ _LIBCPP_HIDE_FROM_ABI _Pointer __get_ptr() const { return _PointerTraits::__to_pointer(__value_ & __ptr_mask); }
+
+ template <class>
+ friend struct _PointerLikeTraits;
+};
+
+template <class _Pointer, __integer_width __int_bit_count, class _IntType>
+struct _PointerLikeTraits<__pointer_int_pair<_Pointer, _IntType, __int_bit_count>> {
+private:
+ using _PointerIntPair = __pointer_int_pair<_Pointer, _IntType, __int_bit_count>;
+
+ static_assert(_PointerLikeTraits<_Pointer>::__low_bits_available >= static_cast<size_t>(__int_bit_count));
+
+public:
+ static constexpr size_t __low_bits_available =
+ _PointerLikeTraits<_Pointer>::__low_bits_available - static_cast<size_t>(__int_bit_count);
+
+ static _LIBCPP_HIDE_FROM_ABI uintptr_t __to_uintptr(_PointerIntPair __ptr) { return __ptr.__value_; }
+
+ static _LIBCPP_HIDE_FROM_ABI _PointerIntPair __to_pointer(uintptr_t __ptr) {
+ _PointerIntPair __tmp{};
+ __tmp.__value_ = __ptr;
+ return __tmp;
+ }
+};
+
+// Make __pointer_int_pair tuple-like
+
+template <class _Pointer, class _IntType, __integer_width __int_bit_count>
+struct tuple_size<__pointer_int_pair<_Pointer, _IntType, __int_bit_count>> : integral_constant<size_t, 2> {};
+
+template <class _Pointer, class _IntType, __integer_width __int_bit_count>
+struct tuple_element<0, __pointer_int_pair<_Pointer, _IntType, __int_bit_count>> {
+ using type = _Pointer;
+};
+
+template <class _Pointer, class _IntType, __integer_width __int_bit_count>
+struct tuple_element<1, __pointer_int_pair<_Pointer, _IntType, __int_bit_count>> {
+ using type = _IntType;
+};
+
+template <size_t __i, class _Pointer, class _IntType, __integer_width __int_bit_count>
+_LIBCPP_HIDE_FROM_ABI auto get(__pointer_int_pair<_Pointer, _IntType, __int_bit_count> __pair) {
+ if constexpr (__i == 0) {
+ return __pair.__get_ptr();
+ } else if constexpr (__i == 1) {
+ return __pair.__get_value();
+ } else {
+ static_assert(__i == 0, "Index out of bounds");
+ }
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___UTILITY_POINTER_INT_PAIR_H
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 48391b2a12095..5d225e747e43a 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -2089,6 +2089,7 @@ module std_private_utility_pair [system] {
}
module std_private_utility_pair_fwd [system] { header "__fwd/pair.h" }
module std_private_utility_piecewise_construct [system] { header "__utility/piecewise_construct.h" }
+module std_private_utility_pointer_int_pair [system] { header "__utility/pointer_int_pair.h" }
module std_private_utility_priority_tag [system] { header "__utility/priority_tag.h" }
module std_private_utility_private_constructor_tag [system] { header "__utility/private_constructor_tag.h" }
module std_private_utility_rel_ops [system] { header "__utility/rel_ops.h" }
diff --git a/libcxx/test/libcxx/utilities/pointer_int_pair/assert.constructor.pass.cpp b/libcxx/test/libcxx/utilities/pointer_int_pair/assert.constructor.pass.cpp
new file mode 100644
index 0000000000000..319455f25a482
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/pointer_int_pair/assert.constructor.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// REQUIRES: has-unix-headers
+// REQUIRES: libcpp-hardening-mode=debug
+// XFAIL: availability-verbose_abort-missing
+
+#include "test_macros.h"
+
+TEST_DIAGNOSTIC_PUSH
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wprivate-header")
+#include <__utility/pointer_int_pair.h>
+TEST_DIAGNOSTIC_POP
+
+#include <cassert>
+
+#include "check_assertion.h"
+
+struct [[gnu::packed]] Packed {
+ char c;
+ int i;
+};
+
+int main(int, char**) {
+ TEST_LIBCPP_ASSERT_FAILURE(
+ (std::__pointer_int_pair<int*, size_t, std::__integer_width{1}>{nullptr, 2}), "integer is too large!");
+
+ TEST_DIAGNOSTIC_PUSH
+ TEST_CLANG_DIAGNOSTIC_IGNORED("-Waddress-of-packed-member") // That's what we're trying to test
+ TEST_GCC_DIAGNOSTIC_IGNORED("-Waddress-of-packed-member")
+ alignas(int) Packed p;
+ TEST_LIBCPP_ASSERT_FAILURE(
+ (std::__pointer_int_pair<int*, size_t, std::__integer_width{1}>{&p.i, 0}), "Pointer alignment is too low!");
+ TEST_DIAGNOSTIC_POP
+
+ return 0;
+}
diff --git a/libcxx/test/libcxx/utilities/pointer_int_pair/constinit.verify.cpp b/libcxx/test/libcxx/utilities/pointer_int_pair/constinit.verify.cpp
new file mode 100644
index 0000000000000..e06a378bf11df
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/pointer_int_pair/constinit.verify.cpp
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Ensure that __pointer_int_pair cannot be constant initialized with a value.
+// This would mean that the constructor is `constexpr`, which should only be
+// possible with compiler magic.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <__utility/pointer_int_pair.h>
+
+template <class Ptr, class UnderlyingType>
+using single_bit_pair = std::__pointer_int_pair<Ptr, UnderlyingType, std::__integer_width{1}>;
+
+constinit int ptr = 0;
+constinit single_bit_pair<int*, size_t> continitiable_pointer_int_pair_values{&ptr, 0}; // expected-error {{variable does not have a constant initializer}}
diff --git a/libcxx/test/libcxx/utilities/pointer_int_pair/pointer_int_pair.pass.cpp b/libcxx/test/libcxx/utilities/pointer_int_pair/pointer_int_pair.pass.cpp
new file mode 100644
index 0000000000000..6ab15d9233663
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/pointer_int_pair/pointer_int_pair.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <__utility/pointer_int_pair.h>
+#include <cassert>
+
+template <class Ptr, class UnderlyingType>
+using single_bit_pair = std::__pointer_int_pair<Ptr, UnderlyingType, std::__integer_width{1}>;
+
+template <class Ptr, class UnderlyingType>
+using two_bit_pair = std::__pointer_int_pair<Ptr, UnderlyingType, std::__integer_width{2}>;
+
+constinit single_bit_pair<int*, size_t> continitiable_pointer_int_pair;
+
+int main(int, char**) {
+ { // __point_int_pair() constructor
+ single_bit_pair<int*, size_t> pair = {};
+ assert(pair.__get_value() == 0);
+ assert(pair.__get_ptr() == nullptr);
+ }
+
+ { // __pointer_int_pair(pointer, int) constructor
+ single_bit_pair<int*, size_t> pair(nullptr, 1);
+ assert(pair.__get_value() == 1);
+ assert(pair.__get_ptr() == nullptr);
+ }
+
+ { // pointer is correctly packed/unpacked (with different types and values)
+ int i;
+ single_bit_pair<int*, size_t> pair(&i, 0);
+ assert(pair.__get_value() == 0);
+ assert(pair.__get_ptr() == &i);
+ }
+ {
+ int i;
+ two_bit_pair<int*, size_t> pair(&i, 2);
+ assert(pair.__get_value() == 2);
+ assert(pair.__get_ptr() == &i);
+ }
+ {
+ short i;
+ single_bit_pair<short*, size_t> pair(&i, 1);
+ assert(pair.__get_value() == 1);
+ assert(pair.__get_ptr() == &i);
+ }
+
+ { // check that a __pointer_int_pair<__pointer_int_pair> works
+ int i;
+ single_bit_pair<single_bit_pair<int*, size_t>, size_t> pair({&i, 1}, 0);
+ assert(pair.__get_value() == 0);
+ assert(pair.__get_ptr().__get_ptr() == &i);
+ assert(pair.__get_ptr().__get_value() == 1);
+ }
+
+ { // check that the tuple protocol is correctly implemented
+ int i;
+ two_bit_pair<int*, size_t> pair{&i, 3};
+ auto [ptr, value] = pair;
+ assert(ptr == &i);
+ assert(value == 3);
+ }
+
+ { // check that the (pointer, int) constructor is implicit
+ int i;
+ two_bit_pair<int*, size_t> pair = {&i, 3};
+ assert(pair.__get_ptr() == &i);
+ assert(pair.__get_value() == 3);
+ }
+
+ { // check that overaligned types work as expected
+ struct alignas(32) Overaligned {
+ int i;
+ };
+
+ Overaligned i;
+ std::__pointer_int_pair<Overaligned*, size_t, std::__integer_width{4}> pair = {&i, 13};
+ assert(pair.__get_ptr() == &i);
+ assert(pair.__get_value() == 13);
+ }
+
+ { // check that types other than size_t work as well
+ int i;
+ single_bit_pair<int*, bool> pair = {&i, true};
+ assert(pair.__get_ptr() == &i);
+ assert(pair.__get_value());
+ static_assert(std::is_same_v<decltype(pair.__get_value()), bool>);
+ }
+ {
+ int i;
+ single_bit_pair<int*, unsigned char> pair = {&i, 1};
+ assert(pair.__get_ptr() == &i);
+ assert(pair.__get_value() == 1);
+ static_assert(std::is_same_v<decltype(pair.__get_value()), unsigned char>);
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/libcxx/utilities/pointer_int_pair/static_asserts.verify.cpp b/libcxx/test/libcxx/utilities/pointer_int_pair/static_asserts.verify.cpp
new file mode 100644
index 0000000000000..544769839679c
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/pointer_int_pair/static_asserts.verify.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include "test_macros.h"
+
+TEST_DIAGNOSTIC_PUSH
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wprivate-header")
+#include <__utility/pointer_int_pair.h>
+TEST_DIAGNOSTIC_POP
+
+// expected-error-re@*:* {{{{static_assert|static assertion}} failed {{.*}}Not enough bits available for requested bit count}}
+std::__pointer_int_pair<char*, size_t, std::__integer_width{2}> ptr1; // expected-note {{here}}
+// expected-error-re@*:* {{{{static_assert|static assertion}} failed {{.*}}_IntType has to be an integral type}}
+std::__pointer_int_pair<int*, int*, std::__integer_width{2}> ptr2; // expected-note {{here}}
+// expected-error-re@*:* {{{{static_assert|static assertion}} failed {{.*}}__pointer_int_pair doesn't work for signed types}}
+std::__pointer_int_pair<int*, signed, std::__integer_width{2}> ptr3; // expected-note {{here}}
>From 7a203002b19f5a2827607e73a998dcd1ace9d135 Mon Sep 17 00:00:00 2001
From: Nikolas Klauser <nikolasklauser at berlin.de>
Date: Tue, 4 Jun 2024 09:15:57 +0200
Subject: [PATCH 2/2] [libc++] Implement P0288R9 (move_only_function)
---
libcxx/docs/FeatureTestMacroTable.rst | 2 +-
libcxx/docs/ReleaseNotes/19.rst | 1 +
libcxx/docs/Status/Cxx23Papers.csv | 2 +-
libcxx/include/CMakeLists.txt | 3 +
libcxx/include/__configuration/abi.h | 4 +-
.../include/__functional/move_only_function.h | 93 +++
.../__functional/move_only_function_common.h | 46 ++
.../__functional/move_only_function_impl.h | 233 ++++++
libcxx/include/__std_clang_module | 1 +
libcxx/include/__utility/pointer_int_pair.h | 3 +
libcxx/include/functional | 1 +
libcxx/include/module.modulemap | 3 +
libcxx/include/version | 2 +-
libcxx/modules/std.cppm.in | 1 +
libcxx/test/libcxx/private_headers.verify.cpp | 717 ++++++++++++++++++
.../func.wrap.move/assert.engaged.cpp | 20 +
.../utilities/pointer_int_pair.pass.cpp | 37 +
.../functional.version.compile.pass.cpp | 32 +-
.../version.version.compile.pass.cpp | 32 +-
.../assignment/functor.pass.cpp | 84 ++
.../func.wrap.move/assignment/move.pass.cpp | 91 +++
.../assignment/move_other.pass.cpp | 62 ++
.../assignment/nullptr.pass.cpp | 73 ++
.../func.wrap.move/call/lvalue.pass.cpp | 102 +++
.../func.wrap.move/call/lvalue_const.pass.cpp | 118 +++
.../call/lvalue_const_noexcept.pass.cpp | 113 +++
.../call/lvalue_noexcept.pass.cpp | 102 +++
.../func.wrap.move/call/normal.pass.cpp | 106 +++
.../func.wrap.move/call/normal_const.pass.cpp | 112 +++
.../call/normal_const_noexcept.pass.cpp | 112 +++
.../call/normal_noexcept.pass.cpp | 106 +++
.../func.wrap.move/call/rvalue.pass.cpp | 104 +++
.../func.wrap.move/call/rvalue_const.pass.cpp | 107 +++
.../call/rvalue_const_noexcept.pass.cpp | 107 +++
.../call/rvalue_noexcept.pass.cpp | 104 +++
.../func.wrap/func.wrap.move/common.h | 80 ++
.../func.wrap.move/ctors/default.pass.cpp | 28 +
.../func.wrap.move/ctors/functor.pass.cpp | 115 +++
.../func.wrap.move/ctors/in_place.pass.cpp | 46 ++
.../ctors/in_place_init_list.pass.cpp | 46 ++
.../func.wrap.move/ctors/move.pass.cpp | 106 +++
.../func.wrap.move/ctors/move_other.pass.cpp | 44 ++
.../func.wrap.move/ctors/nullptr.pass.cpp | 28 +
.../func.wrap.move/swap.adl.pass.cpp | 73 ++
.../func.wrap.move/swap.member.pass.cpp | 73 ++
libcxx/test/support/type_algorithms.h | 36 +
.../generate_feature_test_macro_components.py | 1 -
47 files changed, 3463 insertions(+), 49 deletions(-)
create mode 100644 libcxx/include/__functional/move_only_function.h
create mode 100644 libcxx/include/__functional/move_only_function_common.h
create mode 100644 libcxx/include/__functional/move_only_function_impl.h
create mode 100644 libcxx/test/libcxx/private_headers.verify.cpp
create mode 100644 libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.move/assert.engaged.cpp
create mode 100644 libcxx/test/libcxx/utilities/pointer_int_pair.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/functor.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move_other.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/nullptr.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const_noexcept.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_noexcept.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const_noexcept.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_noexcept.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const_noexcept.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_noexcept.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/common.h
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/default.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/functor.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place_init_list.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move_other.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/nullptr.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.adl.pass.cpp
create mode 100644 libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.member.pass.cpp
diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
index 0297068785e8b..69296fdc98ae2 100644
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -340,7 +340,7 @@ Status
---------------------------------------------------------- -----------------
``__cpp_lib_mdspan`` ``202207L``
---------------------------------------------------------- -----------------
- ``__cpp_lib_move_only_function`` *unimplemented*
+ ``__cpp_lib_move_only_function`` ``202110L``
---------------------------------------------------------- -----------------
``__cpp_lib_optional`` ``202110L``
---------------------------------------------------------- -----------------
diff --git a/libcxx/docs/ReleaseNotes/19.rst b/libcxx/docs/ReleaseNotes/19.rst
index 0bc343acd281c..9e142d2bdda92 100644
--- a/libcxx/docs/ReleaseNotes/19.rst
+++ b/libcxx/docs/ReleaseNotes/19.rst
@@ -54,6 +54,7 @@ Implemented Papers
- P2713R1 - Escaping improvements in ``std::format``
- P2231R1 - Missing ``constexpr`` in ``std::optional`` and ``std::variant``
- P0019R8 - ``std::atomic_ref``
+- P0288R9 - ``move_only_function``
Improvements and New Features
-----------------------------
diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv
index 01387a404f5d6..b5da5cad5f060 100644
--- a/libcxx/docs/Status/Cxx23Papers.csv
+++ b/libcxx/docs/Status/Cxx23Papers.csv
@@ -23,7 +23,7 @@
"`P2136R3 <https://wg21.link/P2136R3>`__","LWG","invoke_r","June 2021","|Complete|","17.0"
"`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|","19.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"
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 289baf2338256..17573d3e67de8 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -399,6 +399,9 @@ set(files
__functional/is_transparent.h
__functional/mem_fn.h
__functional/mem_fun_ref.h
+ __functional/move_only_function.h
+ __functional/move_only_function_common.h
+ __functional/move_only_function_impl.h
__functional/not_fn.h
__functional/operations.h
__functional/perfect_forward.h
diff --git a/libcxx/include/__configuration/abi.h b/libcxx/include/__configuration/abi.h
index 17aceb042f524..31c23ff7fa889 100644
--- a/libcxx/include/__configuration/abi.h
+++ b/libcxx/include/__configuration/abi.h
@@ -90,7 +90,9 @@
# define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY
# define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW
// Dont' add an inline namespace for `std::filesystem`
-# define _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE
+# define _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE
+// Enable clang::trivial_abi for std::move_only_function
+# define _LIBCPP_ABI_SMALL_BUFFER_TRIVIAL_ABI
#elif _LIBCPP_ABI_VERSION == 1
# if !(defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF))
// Enable compiling copies of now inline methods into the dylib to support
diff --git a/libcxx/include/__functional/move_only_function.h b/libcxx/include/__functional/move_only_function.h
new file mode 100644
index 0000000000000..4cda276e37d7f
--- /dev/null
+++ b/libcxx/include/__functional/move_only_function.h
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_H
+#define _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+// move_only_function design:
+//
+// move_only_function has a small buffer with a size of `3 * sizeof(void*)` bytes. This buffer can only be used when the
+// object that should be stored is trivially relocatable (currently only when it is trivially move constructible and
+// trivially destructible). There is also a bool in the lower bits of the vptr stored which is set when the contained
+// object is not trivially destructible.
+//
+// trivially relocatable: It would also be possible to store nothrow_move_constructible types, but that would mean
+// that move_only_function itself would not be trivially relocatable anymore. The decision to keep move_only_function
+// trivially relocatable was made because we expect move_only_function to be mostly used to store a functor. To only
+// forward functors there is std::function_ref (not voted in yet, expected in C++26).
+//
+// buffer size: We did a survey of six implementations from various vendors. Three of them had a buffer size of 24 bytes
+// on 64 bit systems. This also allows storing a std::string or std::vector inside the small buffer (once the compiler
+// has full support of trivially_relocatable annotations).
+//
+// trivially-destructible bit: This allows us to keep the overall binary size smaller because we don't have to store
+// a pointer to a noop function inside the vtable. It also avoids loading the vtable during destruction, potentially
+// resulting in fewer cache misses. The downside is that calling the function now also requires setting the lower bits
+// of the pointer to zero, but this is a very fast operation on modern CPUs.
+
+// NOLINTBEGIN(readability-duplicate-include)
+# define _LIBCPP_IN_MOVE_ONLY_FUNCTION_H
+
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+# define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+# define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &
+# include <__functional/move_only_function_impl.h>
+
+# define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT true
+# define _LIBCPP_MOVE_ONLY_FUNCTION_CV const
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF &&
+# include <__functional/move_only_function_impl.h>
+
+# undef _LIBCPP_IN_MOVE_ONLY_FUNCTION_H
+// NOLINTEND(readability-duplicate-include)
+
+#endif // _LIBCPP_STD_VER > 20
+
+#endif // _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_H
diff --git a/libcxx/include/__functional/move_only_function_common.h b/libcxx/include/__functional/move_only_function_common.h
new file mode 100644
index 0000000000000..45978bfc91aad
--- /dev/null
+++ b/libcxx/include/__functional/move_only_function_common.h
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_COMMON_H
+#define _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_COMMON_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class...>
+class move_only_function;
+
+template <class>
+struct __is_move_only_function : false_type {};
+
+template <class... _Args>
+struct __is_move_only_function<move_only_function<_Args...>> : true_type {};
+
+template <class _BufferT, class _ReturnT, class... _ArgTypes>
+struct _MoveOnlyFunctionTrivialVTable {
+ using _CallFunc = _ReturnT(_BufferT&, _ArgTypes...);
+
+ _CallFunc* __call_;
+};
+
+template <class _BufferT, class _ReturnT, class... _ArgTypes>
+struct _MoveOnlyFunctionNonTrivialVTable : _MoveOnlyFunctionTrivialVTable<_BufferT, _ReturnT, _ArgTypes...> {
+ using _DestroyFunc = void(_BufferT&) noexcept;
+
+ _DestroyFunc* __destroy_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FUNCTIONAL_MOVE_ONLY_FUNCTION_COMMON_H
diff --git a/libcxx/include/__functional/move_only_function_impl.h b/libcxx/include/__functional/move_only_function_impl.h
new file mode 100644
index 0000000000000..9d006ea346162
--- /dev/null
+++ b/libcxx/include/__functional/move_only_function_impl.h
@@ -0,0 +1,233 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// This header is unguarded on purpose. This header is an implementation detail of move_only_function.h
+// and generates multiple versions of std::move_only_function
+
+#include <__config>
+#include <__functional/invoke.h>
+#include <__functional/move_only_function_common.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__utility/exchange.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/pointer_int_pair.h>
+#include <__utility/small_buffer.h>
+#include <__utility/swap.h>
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <new>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_IN_MOVE_ONLY_FUNCTION_H
+# error This header should only be included from move_only_function.h
+#endif
+
+#ifndef _LIBCPP_MOVE_ONLY_FUNCTION_CV
+# define _LIBCPP_MOVE_ONLY_FUNCTION_CV
+#endif
+
+#ifndef _LIBCPP_MOVE_ONLY_FUNCTION_REF
+# define _LIBCPP_MOVE_ONLY_FUNCTION_REF
+# define _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS _LIBCPP_MOVE_ONLY_FUNCTION_CV&
+#else
+# define _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS _LIBCPP_MOVE_ONLY_FUNCTION_CV _LIBCPP_MOVE_ONLY_FUNCTION_REF
+#endif
+
+#ifndef _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT
+# define _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT false
+#endif
+
+#define _LIBCPP_MOVE_ONLY_FUNCTION_CVREF _LIBCPP_MOVE_ONLY_FUNCTION_CV _LIBCPP_MOVE_ONLY_FUNCTION_REF
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef _LIBCPP_ABI_MOVE_ONLY_FUNCTION_TRIVIAL_ABI
+# define _LIBCPP_MOVE_ONLY_FUNCTION_TRIVIAL_ABI [[_Clang::__trivial_abi__]]
+#else
+# define _LIBCPP_MOVE_ONLY_FUNCTION_TRIVIAL_ABI
+#endif
+
+template <class...>
+class move_only_function;
+
+template <class _ReturnT, class... _ArgTypes>
+class _LIBCPP_MOVE_ONLY_FUNCTION_TRIVIAL_ABI move_only_function<_ReturnT(
+ _ArgTypes...) _LIBCPP_MOVE_ONLY_FUNCTION_CVREF noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT)> {
+private:
+ static constexpr size_t __buffer_size_ = 3 * sizeof(void*);
+ static constexpr size_t __buffer_alignment_ = alignof(void*);
+ using _BufferT = __small_buffer<__buffer_size_, __buffer_alignment_>;
+
+ using _TrivialVTable = _MoveOnlyFunctionTrivialVTable<_BufferT, _ReturnT, _ArgTypes...>;
+ using _NonTrivialVTable = _MoveOnlyFunctionNonTrivialVTable<_BufferT, _ReturnT, _ArgTypes...>;
+
+ template <class _Functor>
+ static constexpr _TrivialVTable __trivial_vtable_ = {
+ .__call_ = [](_BufferT& __buffer, _ArgTypes... __args) noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) -> _ReturnT {
+ return std::invoke_r<_ReturnT>(
+ static_cast<_Functor _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS>(*__buffer.__get<_Functor>()),
+ std::forward<_ArgTypes>(__args)...);
+ }};
+
+ template <class _Functor>
+ static constexpr _NonTrivialVTable __non_trivial_vtable_{
+ __trivial_vtable_<_Functor>,
+ [](_BufferT& __buffer) noexcept -> void {
+ std::destroy_at(__buffer.__get<_Functor>());
+ __buffer.__dealloc<_Functor>();
+ },
+ };
+
+ template <class _Functor>
+ _LIBCPP_HIDE_FROM_ABI __pointer_bool_pair<const _TrivialVTable*> __get_vptr() {
+ if constexpr (_BufferT::__fits_in_buffer<_Functor> && is_trivially_destructible_v<_Functor>) {
+ return {&__trivial_vtable_<_Functor>, false};
+ } else {
+ return {&__non_trivial_vtable_<_Functor>, true};
+ }
+ }
+
+ template <class _VT>
+ static constexpr bool __is_callable_from = [] {
+ using _DVT = decay_t<_VT>;
+ if (_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
+ return is_nothrow_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_CVREF, _ArgTypes...> &&
+ is_nothrow_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS, _ArgTypes...>;
+ } else {
+ return is_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_CVREF, _ArgTypes...> &&
+ is_invocable_r_v<_ReturnT, _DVT _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS, _ArgTypes...>;
+ }
+ }();
+
+ template <class _Func, class... _Args>
+ _LIBCPP_HIDE_FROM_ABI void __construct(_Args&&... __args) {
+ static_assert(is_constructible_v<decay_t<_Func>, _Func>);
+
+ using _StoredFunc = decay_t<_Func>;
+ __vtable_ = __get_vptr<_StoredFunc>();
+ __buffer_.__construct<_StoredFunc>(std::forward<_Args>(__args)...);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI void __reset() {
+ if (__vtable_.__get_value())
+ static_cast<const _NonTrivialVTable*>(__vtable_.__get_ptr())->__destroy_(__buffer_);
+ __vtable_ = {};
+ }
+
+public:
+ using result_type = _ReturnT;
+
+ // [func.wrap.move.ctor]
+ move_only_function() noexcept = default;
+ _LIBCPP_HIDE_FROM_ABI move_only_function(nullptr_t) noexcept {}
+ _LIBCPP_HIDE_FROM_ABI move_only_function(move_only_function&& __other) noexcept
+ : __vtable_(__other.__vtable_), __buffer_(std::move(__other.__buffer_)) {
+ __other.__vtable_ = {};
+ }
+
+ template <class _Func>
+ requires(!is_same_v<remove_cvref_t<_Func>, move_only_function> && !__is_inplace_type<_Func>::value &&
+ __is_callable_from<_Func>)
+ _LIBCPP_HIDE_FROM_ABI move_only_function(_Func&& __func) noexcept {
+ using _StoredFunc = decay_t<_Func>;
+
+ if constexpr ((is_pointer_v<_StoredFunc> && is_function_v<remove_pointer_t<_StoredFunc>>) ||
+ is_member_function_pointer_v<_StoredFunc>) {
+ if (__func != nullptr) {
+ __vtable_ = __get_vptr<_StoredFunc>();
+ static_assert(_BufferT::__fits_in_buffer<_StoredFunc>);
+ __buffer_.__construct<_StoredFunc>(std::forward<_Func>(__func));
+ }
+ } else if constexpr (__is_move_only_function<_StoredFunc>::value) {
+ if (__func) {
+ __vtable_ = std::exchange(__func.__vtable_, {});
+ __buffer_ = std::move(__func.__buffer_);
+ }
+ } else {
+ __construct<_Func>(std::forward<_Func>(__func));
+ }
+ }
+
+ template <class _Func, class... _Args>
+ requires is_constructible_v<decay_t<_Func>, _Args...> && __is_callable_from<_Func>
+ _LIBCPP_HIDE_FROM_ABI explicit move_only_function(in_place_type_t<_Func>, _Args&&... __args) {
+ static_assert(is_same_v<decay_t<_Func>, _Func>);
+ __construct<_Func>(std::forward<_Args>(__args)...);
+ }
+
+ template <class _Func, class _InitListType, class... _Args>
+ requires is_constructible_v<decay_t<_Func>, initializer_list<_InitListType>&, _Args...> && __is_callable_from<_Func>
+ _LIBCPP_HIDE_FROM_ABI explicit move_only_function(
+ in_place_type_t<_Func>, initializer_list<_InitListType> __il, _Args&&... __args) {
+ static_assert(is_same_v<decay_t<_Func>, _Func>);
+ __construct<_Func>(__il, std::forward<_Args>(__args)...);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI move_only_function& operator=(move_only_function&& __other) noexcept {
+ move_only_function(std::move(__other)).swap(*this);
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI move_only_function& operator=(nullptr_t) noexcept {
+ __reset();
+ return *this;
+ }
+
+ template <class _Func>
+ requires(!is_same_v<remove_cvref_t<_Func>, move_only_function> && !__is_inplace_type<_Func>::value &&
+ __is_callable_from<_Func>)
+ _LIBCPP_HIDE_FROM_ABI move_only_function& operator=(_Func&& __func) {
+ move_only_function(std::forward<_Func>(__func)).swap(*this);
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI ~move_only_function() { __reset(); }
+
+ // [func.wrap.move.inv]
+ _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept { return __vtable_.__get_ptr() != nullptr; }
+
+ _LIBCPP_HIDE_FROM_ABI _ReturnT operator()(_ArgTypes... __args) _LIBCPP_MOVE_ONLY_FUNCTION_CVREF
+ noexcept(_LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT) {
+ _LIBCPP_ASSERT(static_cast<bool>(*this), "Tried to call a disengaged move_only_function");
+ const auto __call = static_cast<_ReturnT (*)(_BufferT&, _ArgTypes...)>(__vtable_.__get_ptr()->__call_);
+ return __call(__buffer_, std::forward<_ArgTypes>(__args)...);
+ }
+
+ // [func.wrap.move.util]
+ _LIBCPP_HIDE_FROM_ABI void swap(move_only_function& __other) noexcept {
+ std::swap(__vtable_, __other.__vtable_);
+ std::swap(__buffer_, __other.__buffer_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend void swap(move_only_function& __lhs, move_only_function& __rhs) noexcept {
+ __lhs.swap(__rhs);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend bool operator==(const move_only_function& __func, nullptr_t) noexcept { return !__func; }
+
+private:
+ __pointer_bool_pair<const _TrivialVTable*> __vtable_ = {};
+ mutable _BufferT __buffer_;
+
+ template <class...>
+ friend class move_only_function;
+};
+
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_CV
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_REF
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_NOEXCEPT
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_INVOKE_QUALS
+#undef _LIBCPP_MOVE_ONLY_FUNCTION_CVREF
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__std_clang_module b/libcxx/include/__std_clang_module
index 18d6ce6b46c1f..e48a3e876ef84 100644
--- a/libcxx/include/__std_clang_module
+++ b/libcxx/include/__std_clang_module
@@ -136,6 +136,7 @@
#include <mdspan>
#include <memory>
#include <memory_resource>
+#include <module.modulemap.in>
#include <mutex>
#include <new>
#include <numbers>
diff --git a/libcxx/include/__utility/pointer_int_pair.h b/libcxx/include/__utility/pointer_int_pair.h
index 9c64b023c60e6..5a08b74686166 100644
--- a/libcxx/include/__utility/pointer_int_pair.h
+++ b/libcxx/include/__utility/pointer_int_pair.h
@@ -121,6 +121,9 @@ struct _PointerLikeTraits<__pointer_int_pair<_Pointer, _IntType, __int_bit_count
}
};
+template <class _Pointer>
+using __pointer_bool_pair = __pointer_int_pair<_Pointer, bool, __integer_width{1}>;
+
// Make __pointer_int_pair tuple-like
template <class _Pointer, class _IntType, __integer_width __int_bit_count>
diff --git a/libcxx/include/functional b/libcxx/include/functional
index 27cf21e1a4c8b..8e2cceb3e5d9f 100644
--- a/libcxx/include/functional
+++ b/libcxx/include/functional
@@ -546,6 +546,7 @@ POLICY: For non-variadic implementations, the number of arguments is limited
#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>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 5d225e747e43a..335c0a87c13ea 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -1354,6 +1354,9 @@ module std_private_functional_invoke [system] {
module std_private_functional_is_transparent [system] { header "__functional/is_transparent.h" }
module std_private_functional_mem_fn [system] { header "__functional/mem_fn.h" }
module std_private_functional_mem_fun_ref [system] { header "__functional/mem_fun_ref.h" }
+module std_private_functional_move_only_function [system] { header "__functional/move_only_function.h" }
+module std_private_functional_move_only_function_common [system] { header "__functional/move_only_function_common.h" }
+module std_private_functional_move_only_function_impl [system] { textual header "__functional/move_only_function_impl.h" }
module std_private_functional_not_fn [system] { header "__functional/not_fn.h" }
module std_private_functional_operations [system] { header "__functional/operations.h" }
module std_private_functional_perfect_forward [system] {
diff --git a/libcxx/include/version b/libcxx/include/version
index d433e1b1c9cea..0f2f940816c45 100644
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -465,7 +465,7 @@ __cpp_lib_void_t 201411L <type_traits>
# define __cpp_lib_ios_noreplace 202207L
# define __cpp_lib_is_scoped_enum 202011L
# define __cpp_lib_mdspan 202207L
-// # define __cpp_lib_move_only_function 202110L
+# define __cpp_lib_move_only_function 202110L
# undef __cpp_lib_optional
# define __cpp_lib_optional 202110L
// # define __cpp_lib_out_ptr 202106L
diff --git a/libcxx/modules/std.cppm.in b/libcxx/modules/std.cppm.in
index b8d89130aae98..9193edc7c2ba8 100644
--- a/libcxx/modules/std.cppm.in
+++ b/libcxx/modules/std.cppm.in
@@ -106,6 +106,7 @@ module;
#include <mdspan>
#include <memory>
#include <memory_resource>
+#include <module.modulemap.in>
#include <mutex>
#include <new>
#include <numbers>
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
new file mode 100644
index 0000000000000..fc76655325720
--- /dev/null
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -0,0 +1,717 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 test ensures that we produce a diagnostic when we use a private header
+// from user code.
+
+// REQUIRES: modules-build
+
+/*
+BEGIN-SCRIPT
+
+for header in private_headers:
+ # Skip headers that are not private yet in the modulemap
+ if header in private_headers_still_public_in_modules:
+ continue
+
+ # Skip private headers that start with __support -- those are not in the modulemap yet
+ if header.startswith('__support'):
+ continue
+
+ print("{ifdef}#{indent}include <{header}> // {expected_error}@*:* {{{{use of private header from outside its module: '{header}'}}}}{endif}".format(
+ ifdef='#if ' + header_restrictions[header] + '\n' if header in header_restrictions else '',
+ indent=' ' if header in header_restrictions else '',
+ header=header,
+ expected_error='expected-error',
+ endif='\n#endif' if header in header_restrictions else ''
+ ))
+
+END-SCRIPT
+*/
+
+// DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
+// GENERATED-MARKER
+#include <__algorithm/adjacent_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/adjacent_find.h'}}
+#include <__algorithm/all_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/all_of.h'}}
+#include <__algorithm/any_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/any_of.h'}}
+#include <__algorithm/binary_search.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/binary_search.h'}}
+#include <__algorithm/clamp.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/clamp.h'}}
+#include <__algorithm/comp.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/comp.h'}}
+#include <__algorithm/comp_ref_type.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/comp_ref_type.h'}}
+#include <__algorithm/copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy.h'}}
+#include <__algorithm/copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy_backward.h'}}
+#include <__algorithm/copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy_if.h'}}
+#include <__algorithm/copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/copy_n.h'}}
+#include <__algorithm/count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/count.h'}}
+#include <__algorithm/count_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/count_if.h'}}
+#include <__algorithm/equal.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/equal.h'}}
+#include <__algorithm/equal_range.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/equal_range.h'}}
+#include <__algorithm/fill.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/fill.h'}}
+#include <__algorithm/fill_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/fill_n.h'}}
+#include <__algorithm/find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/find.h'}}
+#include <__algorithm/find_end.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/find_end.h'}}
+#include <__algorithm/find_first_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/find_first_of.h'}}
+#include <__algorithm/find_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/find_if.h'}}
+#include <__algorithm/find_if_not.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/find_if_not.h'}}
+#include <__algorithm/for_each.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/for_each.h'}}
+#include <__algorithm/for_each_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/for_each_n.h'}}
+#include <__algorithm/generate.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/generate.h'}}
+#include <__algorithm/generate_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/generate_n.h'}}
+#include <__algorithm/half_positive.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/half_positive.h'}}
+#include <__algorithm/in_found_result.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/in_found_result.h'}}
+#include <__algorithm/in_fun_result.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/in_fun_result.h'}}
+#include <__algorithm/in_in_out_result.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/in_in_out_result.h'}}
+#include <__algorithm/in_in_result.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/in_in_result.h'}}
+#include <__algorithm/in_out_out_result.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/in_out_out_result.h'}}
+#include <__algorithm/in_out_result.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/in_out_result.h'}}
+#include <__algorithm/includes.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/includes.h'}}
+#include <__algorithm/inplace_merge.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/inplace_merge.h'}}
+#include <__algorithm/is_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/is_heap.h'}}
+#include <__algorithm/is_heap_until.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/is_heap_until.h'}}
+#include <__algorithm/is_partitioned.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/is_partitioned.h'}}
+#include <__algorithm/is_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/is_permutation.h'}}
+#include <__algorithm/is_sorted.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/is_sorted.h'}}
+#include <__algorithm/is_sorted_until.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/is_sorted_until.h'}}
+#include <__algorithm/iter_swap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/iter_swap.h'}}
+#include <__algorithm/iterator_operations.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/iterator_operations.h'}}
+#include <__algorithm/lexicographical_compare.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/lexicographical_compare.h'}}
+#include <__algorithm/lower_bound.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/lower_bound.h'}}
+#include <__algorithm/make_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/make_heap.h'}}
+#include <__algorithm/make_projected.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/make_projected.h'}}
+#include <__algorithm/max.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/max.h'}}
+#include <__algorithm/max_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/max_element.h'}}
+#include <__algorithm/merge.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/merge.h'}}
+#include <__algorithm/min.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/min.h'}}
+#include <__algorithm/min_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/min_element.h'}}
+#include <__algorithm/min_max_result.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/min_max_result.h'}}
+#include <__algorithm/minmax.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/minmax.h'}}
+#include <__algorithm/minmax_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/minmax_element.h'}}
+#include <__algorithm/mismatch.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/mismatch.h'}}
+#include <__algorithm/move.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/move.h'}}
+#include <__algorithm/move_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/move_backward.h'}}
+#include <__algorithm/next_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/next_permutation.h'}}
+#include <__algorithm/none_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/none_of.h'}}
+#include <__algorithm/nth_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/nth_element.h'}}
+#include <__algorithm/partial_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort.h'}}
+#include <__algorithm/partial_sort_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort_copy.h'}}
+#include <__algorithm/partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition.h'}}
+#include <__algorithm/partition_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_copy.h'}}
+#include <__algorithm/partition_point.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_point.h'}}
+#include <__algorithm/pop_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/pop_heap.h'}}
+#include <__algorithm/prev_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/prev_permutation.h'}}
+#include <__algorithm/push_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/push_heap.h'}}
+#include <__algorithm/ranges_adjacent_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_adjacent_find.h'}}
+#include <__algorithm/ranges_all_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_all_of.h'}}
+#include <__algorithm/ranges_any_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_any_of.h'}}
+#include <__algorithm/ranges_binary_search.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_binary_search.h'}}
+#include <__algorithm/ranges_clamp.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_clamp.h'}}
+#include <__algorithm/ranges_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy.h'}}
+#include <__algorithm/ranges_copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_backward.h'}}
+#include <__algorithm/ranges_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_if.h'}}
+#include <__algorithm/ranges_copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_n.h'}}
+#include <__algorithm/ranges_count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count.h'}}
+#include <__algorithm/ranges_count_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count_if.h'}}
+#include <__algorithm/ranges_equal.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_equal.h'}}
+#include <__algorithm/ranges_equal_range.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_equal_range.h'}}
+#include <__algorithm/ranges_fill.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill.h'}}
+#include <__algorithm/ranges_fill_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill_n.h'}}
+#include <__algorithm/ranges_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find.h'}}
+#include <__algorithm/ranges_find_end.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_end.h'}}
+#include <__algorithm/ranges_find_first_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_first_of.h'}}
+#include <__algorithm/ranges_find_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if.h'}}
+#include <__algorithm/ranges_find_if_not.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if_not.h'}}
+#include <__algorithm/ranges_for_each.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each.h'}}
+#include <__algorithm/ranges_for_each_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each_n.h'}}
+#include <__algorithm/ranges_generate.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_generate.h'}}
+#include <__algorithm/ranges_generate_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_generate_n.h'}}
+#include <__algorithm/ranges_includes.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_includes.h'}}
+#include <__algorithm/ranges_inplace_merge.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_inplace_merge.h'}}
+#include <__algorithm/ranges_is_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_heap.h'}}
+#include <__algorithm/ranges_is_heap_until.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_heap_until.h'}}
+#include <__algorithm/ranges_is_partitioned.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_partitioned.h'}}
+#include <__algorithm/ranges_is_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_permutation.h'}}
+#include <__algorithm/ranges_is_sorted.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_sorted.h'}}
+#include <__algorithm/ranges_is_sorted_until.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_sorted_until.h'}}
+#include <__algorithm/ranges_iterator_concept.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_iterator_concept.h'}}
+#include <__algorithm/ranges_lexicographical_compare.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_lexicographical_compare.h'}}
+#include <__algorithm/ranges_lower_bound.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_lower_bound.h'}}
+#include <__algorithm/ranges_make_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_make_heap.h'}}
+#include <__algorithm/ranges_max.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max.h'}}
+#include <__algorithm/ranges_max_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max_element.h'}}
+#include <__algorithm/ranges_merge.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_merge.h'}}
+#include <__algorithm/ranges_min.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min.h'}}
+#include <__algorithm/ranges_min_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min_element.h'}}
+#include <__algorithm/ranges_minmax.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax.h'}}
+#include <__algorithm/ranges_minmax_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax_element.h'}}
+#include <__algorithm/ranges_mismatch.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_mismatch.h'}}
+#include <__algorithm/ranges_move.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_move.h'}}
+#include <__algorithm/ranges_move_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_move_backward.h'}}
+#include <__algorithm/ranges_next_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_next_permutation.h'}}
+#include <__algorithm/ranges_none_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_none_of.h'}}
+#include <__algorithm/ranges_nth_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_nth_element.h'}}
+#include <__algorithm/ranges_partial_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_partial_sort.h'}}
+#include <__algorithm/ranges_partial_sort_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_partial_sort_copy.h'}}
+#include <__algorithm/ranges_partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_partition.h'}}
+#include <__algorithm/ranges_partition_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_partition_copy.h'}}
+#include <__algorithm/ranges_partition_point.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_partition_point.h'}}
+#include <__algorithm/ranges_pop_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_pop_heap.h'}}
+#include <__algorithm/ranges_prev_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_prev_permutation.h'}}
+#include <__algorithm/ranges_push_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_push_heap.h'}}
+#include <__algorithm/ranges_remove.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_remove.h'}}
+#include <__algorithm/ranges_remove_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_remove_copy.h'}}
+#include <__algorithm/ranges_remove_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_remove_copy_if.h'}}
+#include <__algorithm/ranges_remove_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_remove_if.h'}}
+#include <__algorithm/ranges_replace.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace.h'}}
+#include <__algorithm/ranges_replace_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace_copy.h'}}
+#include <__algorithm/ranges_replace_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace_copy_if.h'}}
+#include <__algorithm/ranges_replace_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace_if.h'}}
+#include <__algorithm/ranges_reverse.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_reverse.h'}}
+#include <__algorithm/ranges_reverse_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_reverse_copy.h'}}
+#include <__algorithm/ranges_rotate.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_rotate.h'}}
+#include <__algorithm/ranges_rotate_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_rotate_copy.h'}}
+#include <__algorithm/ranges_sample.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_sample.h'}}
+#include <__algorithm/ranges_search.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_search.h'}}
+#include <__algorithm/ranges_search_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_search_n.h'}}
+#include <__algorithm/ranges_set_difference.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_difference.h'}}
+#include <__algorithm/ranges_set_intersection.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_intersection.h'}}
+#include <__algorithm/ranges_set_symmetric_difference.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_symmetric_difference.h'}}
+#include <__algorithm/ranges_set_union.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_set_union.h'}}
+#include <__algorithm/ranges_shuffle.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_shuffle.h'}}
+#include <__algorithm/ranges_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_sort.h'}}
+#include <__algorithm/ranges_sort_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_sort_heap.h'}}
+#include <__algorithm/ranges_stable_partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_stable_partition.h'}}
+#include <__algorithm/ranges_stable_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_stable_sort.h'}}
+#include <__algorithm/ranges_swap_ranges.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_swap_ranges.h'}}
+#include <__algorithm/ranges_transform.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_transform.h'}}
+#include <__algorithm/ranges_unique.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_unique.h'}}
+#include <__algorithm/ranges_unique_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_unique_copy.h'}}
+#include <__algorithm/ranges_upper_bound.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_upper_bound.h'}}
+#include <__algorithm/remove.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove.h'}}
+#include <__algorithm/remove_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove_copy.h'}}
+#include <__algorithm/remove_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove_copy_if.h'}}
+#include <__algorithm/remove_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove_if.h'}}
+#include <__algorithm/replace.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/replace.h'}}
+#include <__algorithm/replace_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/replace_copy.h'}}
+#include <__algorithm/replace_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/replace_copy_if.h'}}
+#include <__algorithm/replace_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/replace_if.h'}}
+#include <__algorithm/reverse.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/reverse.h'}}
+#include <__algorithm/reverse_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/reverse_copy.h'}}
+#include <__algorithm/rotate.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/rotate.h'}}
+#include <__algorithm/rotate_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/rotate_copy.h'}}
+#include <__algorithm/sample.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/sample.h'}}
+#include <__algorithm/search.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/search.h'}}
+#include <__algorithm/search_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/search_n.h'}}
+#include <__algorithm/set_difference.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/set_difference.h'}}
+#include <__algorithm/set_intersection.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/set_intersection.h'}}
+#include <__algorithm/set_symmetric_difference.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/set_symmetric_difference.h'}}
+#include <__algorithm/set_union.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/set_union.h'}}
+#include <__algorithm/shift_left.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/shift_left.h'}}
+#include <__algorithm/shift_right.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/shift_right.h'}}
+#include <__algorithm/shuffle.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/shuffle.h'}}
+#include <__algorithm/sift_down.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/sift_down.h'}}
+#include <__algorithm/sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/sort.h'}}
+#include <__algorithm/sort_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/sort_heap.h'}}
+#include <__algorithm/stable_partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/stable_partition.h'}}
+#include <__algorithm/stable_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/stable_sort.h'}}
+#include <__algorithm/swap_ranges.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/swap_ranges.h'}}
+#include <__algorithm/transform.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/transform.h'}}
+#include <__algorithm/uniform_random_bit_generator_adaptor.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/uniform_random_bit_generator_adaptor.h'}}
+#include <__algorithm/unique.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/unique.h'}}
+#include <__algorithm/unique_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/unique_copy.h'}}
+#include <__algorithm/unwrap_iter.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/unwrap_iter.h'}}
+#include <__algorithm/unwrap_range.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/unwrap_range.h'}}
+#include <__algorithm/upper_bound.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/upper_bound.h'}}
+#include <__availability> // expected-error@*:* {{use of private header from outside its module: '__availability'}}
+#include <__bit/bit_cast.h> // expected-error@*:* {{use of private header from outside its module: '__bit/bit_cast.h'}}
+#include <__bit/byteswap.h> // expected-error@*:* {{use of private header from outside its module: '__bit/byteswap.h'}}
+#include <__bit_reference> // expected-error@*:* {{use of private header from outside its module: '__bit_reference'}}
+#include <__bits> // expected-error@*:* {{use of private header from outside its module: '__bits'}}
+#include <__charconv/chars_format.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/chars_format.h'}}
+#include <__charconv/from_chars_result.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/from_chars_result.h'}}
+#include <__charconv/tables.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/tables.h'}}
+#include <__charconv/to_chars_base_10.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/to_chars_base_10.h'}}
+#include <__charconv/to_chars_result.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/to_chars_result.h'}}
+#include <__chrono/calendar.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/calendar.h'}}
+#include <__chrono/convert_to_timespec.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/convert_to_timespec.h'}}
+#include <__chrono/convert_to_tm.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/convert_to_tm.h'}}
+#include <__chrono/day.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/day.h'}}
+#include <__chrono/duration.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/duration.h'}}
+#include <__chrono/file_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/file_clock.h'}}
+#include <__chrono/formatter.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/formatter.h'}}
+#include <__chrono/hh_mm_ss.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/hh_mm_ss.h'}}
+#include <__chrono/high_resolution_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/high_resolution_clock.h'}}
+#include <__chrono/literals.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/literals.h'}}
+#include <__chrono/month.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/month.h'}}
+#include <__chrono/month_weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/month_weekday.h'}}
+#include <__chrono/monthday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/monthday.h'}}
+#include <__chrono/ostream.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/ostream.h'}}
+#include <__chrono/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/parser_std_format_spec.h'}}
+#include <__chrono/statically_widen.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/statically_widen.h'}}
+#include <__chrono/steady_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/steady_clock.h'}}
+#include <__chrono/system_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/system_clock.h'}}
+#include <__chrono/time_point.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/time_point.h'}}
+#include <__chrono/weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/weekday.h'}}
+#include <__chrono/year.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year.h'}}
+#include <__chrono/year_month.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month.h'}}
+#include <__chrono/year_month_day.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month_day.h'}}
+#include <__chrono/year_month_weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month_weekday.h'}}
+#include <__compare/common_comparison_category.h> // expected-error@*:* {{use of private header from outside its module: '__compare/common_comparison_category.h'}}
+#include <__compare/compare_partial_order_fallback.h> // expected-error@*:* {{use of private header from outside its module: '__compare/compare_partial_order_fallback.h'}}
+#include <__compare/compare_strong_order_fallback.h> // expected-error@*:* {{use of private header from outside its module: '__compare/compare_strong_order_fallback.h'}}
+#include <__compare/compare_three_way.h> // expected-error@*:* {{use of private header from outside its module: '__compare/compare_three_way.h'}}
+#include <__compare/compare_three_way_result.h> // expected-error@*:* {{use of private header from outside its module: '__compare/compare_three_way_result.h'}}
+#include <__compare/compare_weak_order_fallback.h> // expected-error@*:* {{use of private header from outside its module: '__compare/compare_weak_order_fallback.h'}}
+#include <__compare/is_eq.h> // expected-error@*:* {{use of private header from outside its module: '__compare/is_eq.h'}}
+#include <__compare/ordering.h> // expected-error@*:* {{use of private header from outside its module: '__compare/ordering.h'}}
+#include <__compare/partial_order.h> // expected-error@*:* {{use of private header from outside its module: '__compare/partial_order.h'}}
+#include <__compare/strong_order.h> // expected-error@*:* {{use of private header from outside its module: '__compare/strong_order.h'}}
+#include <__compare/synth_three_way.h> // expected-error@*:* {{use of private header from outside its module: '__compare/synth_three_way.h'}}
+#include <__compare/three_way_comparable.h> // expected-error@*:* {{use of private header from outside its module: '__compare/three_way_comparable.h'}}
+#include <__compare/weak_order.h> // expected-error@*:* {{use of private header from outside its module: '__compare/weak_order.h'}}
+#include <__concepts/arithmetic.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/arithmetic.h'}}
+#include <__concepts/assignable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/assignable.h'}}
+#include <__concepts/boolean_testable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/boolean_testable.h'}}
+#include <__concepts/class_or_enum.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/class_or_enum.h'}}
+#include <__concepts/common_reference_with.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/common_reference_with.h'}}
+#include <__concepts/common_with.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/common_with.h'}}
+#include <__concepts/constructible.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/constructible.h'}}
+#include <__concepts/convertible_to.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/convertible_to.h'}}
+#include <__concepts/copyable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/copyable.h'}}
+#include <__concepts/derived_from.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/derived_from.h'}}
+#include <__concepts/destructible.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/destructible.h'}}
+#include <__concepts/different_from.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/different_from.h'}}
+#include <__concepts/equality_comparable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/equality_comparable.h'}}
+#include <__concepts/invocable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/invocable.h'}}
+#include <__concepts/movable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/movable.h'}}
+#include <__concepts/predicate.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/predicate.h'}}
+#include <__concepts/regular.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/regular.h'}}
+#include <__concepts/relation.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/relation.h'}}
+#include <__concepts/same_as.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/same_as.h'}}
+#include <__concepts/semiregular.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/semiregular.h'}}
+#include <__concepts/swappable.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/swappable.h'}}
+#include <__concepts/totally_ordered.h> // expected-error@*:* {{use of private header from outside its module: '__concepts/totally_ordered.h'}}
+#include <__coroutine/coroutine_handle.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_handle.h'}}
+#include <__coroutine/coroutine_traits.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_traits.h'}}
+#include <__coroutine/noop_coroutine_handle.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/noop_coroutine_handle.h'}}
+#include <__coroutine/trivial_awaitables.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/trivial_awaitables.h'}}
+#include <__debug_utils/randomize_range.h> // expected-error@*:* {{use of private header from outside its module: '__debug_utils/randomize_range.h'}}
+#include <__errc> // expected-error@*:* {{use of private header from outside its module: '__errc'}}
+#include <__expected/bad_expected_access.h> // expected-error@*:* {{use of private header from outside its module: '__expected/bad_expected_access.h'}}
+#include <__expected/expected.h> // expected-error@*:* {{use of private header from outside its module: '__expected/expected.h'}}
+#include <__expected/unexpect.h> // expected-error@*:* {{use of private header from outside its module: '__expected/unexpect.h'}}
+#include <__expected/unexpected.h> // expected-error@*:* {{use of private header from outside its module: '__expected/unexpected.h'}}
+#include <__filesystem/copy_options.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/copy_options.h'}}
+#include <__filesystem/directory_entry.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_entry.h'}}
+#include <__filesystem/directory_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_iterator.h'}}
+#include <__filesystem/directory_options.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_options.h'}}
+#include <__filesystem/file_status.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/file_status.h'}}
+#include <__filesystem/file_time_type.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/file_time_type.h'}}
+#include <__filesystem/file_type.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/file_type.h'}}
+#include <__filesystem/filesystem_error.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/filesystem_error.h'}}
+#include <__filesystem/operations.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/operations.h'}}
+#include <__filesystem/path.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/path.h'}}
+#include <__filesystem/path_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/path_iterator.h'}}
+#include <__filesystem/perm_options.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/perm_options.h'}}
+#include <__filesystem/perms.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/perms.h'}}
+#include <__filesystem/recursive_directory_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/recursive_directory_iterator.h'}}
+#include <__filesystem/space_info.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/space_info.h'}}
+#include <__filesystem/u8path.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/u8path.h'}}
+#include <__format/buffer.h> // expected-error@*:* {{use of private header from outside its module: '__format/buffer.h'}}
+#include <__format/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__format/concepts.h'}}
+#include <__format/enable_insertable.h> // expected-error@*:* {{use of private header from outside its module: '__format/enable_insertable.h'}}
+#include <__format/escaped_output_table.h> // expected-error@*:* {{use of private header from outside its module: '__format/escaped_output_table.h'}}
+#include <__format/extended_grapheme_cluster_table.h> // expected-error@*:* {{use of private header from outside its module: '__format/extended_grapheme_cluster_table.h'}}
+#include <__format/format_arg.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_arg.h'}}
+#include <__format/format_arg_store.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_arg_store.h'}}
+#include <__format/format_args.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_args.h'}}
+#include <__format/format_context.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_context.h'}}
+#include <__format/format_error.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_error.h'}}
+#include <__format/format_functions.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_functions.h'}}
+#include <__format/format_fwd.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_fwd.h'}}
+#include <__format/format_parse_context.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_parse_context.h'}}
+#include <__format/format_string.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_string.h'}}
+#include <__format/format_to_n_result.h> // expected-error@*:* {{use of private header from outside its module: '__format/format_to_n_result.h'}}
+#include <__format/formatter.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter.h'}}
+#include <__format/formatter_bool.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_bool.h'}}
+#include <__format/formatter_char.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_char.h'}}
+#include <__format/formatter_floating_point.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_floating_point.h'}}
+#include <__format/formatter_integer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integer.h'}}
+#include <__format/formatter_integral.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_integral.h'}}
+#include <__format/formatter_output.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_output.h'}}
+#include <__format/formatter_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_pointer.h'}}
+#include <__format/formatter_string.h> // expected-error@*:* {{use of private header from outside its module: '__format/formatter_string.h'}}
+#include <__format/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__format/parser_std_format_spec.h'}}
+#include <__format/range_default_formatter.h> // expected-error@*:* {{use of private header from outside its module: '__format/range_default_formatter.h'}}
+#include <__format/unicode.h> // expected-error@*:* {{use of private header from outside its module: '__format/unicode.h'}}
+#include <__functional/binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_function.h'}}
+#include <__functional/binary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binary_negate.h'}}
+#include <__functional/bind.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind.h'}}
+#include <__functional/bind_back.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_back.h'}}
+#include <__functional/bind_front.h> // expected-error@*:* {{use of private header from outside its module: '__functional/bind_front.h'}}
+#include <__functional/binder1st.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binder1st.h'}}
+#include <__functional/binder2nd.h> // expected-error@*:* {{use of private header from outside its module: '__functional/binder2nd.h'}}
+#include <__functional/boyer_moore_searcher.h> // expected-error@*:* {{use of private header from outside its module: '__functional/boyer_moore_searcher.h'}}
+#include <__functional/compose.h> // expected-error@*:* {{use of private header from outside its module: '__functional/compose.h'}}
+#include <__functional/default_searcher.h> // expected-error@*:* {{use of private header from outside its module: '__functional/default_searcher.h'}}
+#include <__functional/function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/function.h'}}
+#include <__functional/hash.h> // expected-error@*:* {{use of private header from outside its module: '__functional/hash.h'}}
+#include <__functional/identity.h> // expected-error@*:* {{use of private header from outside its module: '__functional/identity.h'}}
+#include <__functional/invoke.h> // expected-error@*:* {{use of private header from outside its module: '__functional/invoke.h'}}
+#include <__functional/is_transparent.h> // expected-error@*:* {{use of private header from outside its module: '__functional/is_transparent.h'}}
+#include <__functional/mem_fn.h> // expected-error@*:* {{use of private header from outside its module: '__functional/mem_fn.h'}}
+#include <__functional/mem_fun_ref.h> // expected-error@*:* {{use of private header from outside its module: '__functional/mem_fun_ref.h'}}
+#include <__functional/move_only_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/move_only_function.h'}}
+#include <__functional/move_only_function_common.h> // expected-error@*:* {{use of private header from outside its module: '__functional/move_only_function_common.h'}}
+#include <__functional/move_only_function_impl.h> // expected-error@*:* {{use of private header from outside its module: '__functional/move_only_function_impl.h'}}
+#include <__functional/not_fn.h> // expected-error@*:* {{use of private header from outside its module: '__functional/not_fn.h'}}
+#include <__functional/operations.h> // expected-error@*:* {{use of private header from outside its module: '__functional/operations.h'}}
+#include <__functional/perfect_forward.h> // expected-error@*:* {{use of private header from outside its module: '__functional/perfect_forward.h'}}
+#include <__functional/pointer_to_binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_binary_function.h'}}
+#include <__functional/pointer_to_unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_unary_function.h'}}
+#include <__functional/ranges_operations.h> // expected-error@*:* {{use of private header from outside its module: '__functional/ranges_operations.h'}}
+#include <__functional/reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__functional/reference_wrapper.h'}}
+#include <__functional/unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_function.h'}}
+#include <__functional/unary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_negate.h'}}
+#include <__functional/unwrap_ref.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unwrap_ref.h'}}
+#include <__functional/weak_result_type.h> // expected-error@*:* {{use of private header from outside its module: '__functional/weak_result_type.h'}}
+#include <__fwd/array.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/array.h'}}
+#include <__fwd/get.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/get.h'}}
+#include <__fwd/hash.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/hash.h'}}
+#include <__fwd/memory_resource.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/memory_resource.h'}}
+#include <__fwd/pair.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/pair.h'}}
+#include <__fwd/span.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/span.h'}}
+#include <__fwd/string.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string.h'}}
+#include <__fwd/string_view.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string_view.h'}}
+#include <__fwd/tuple.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/tuple.h'}}
+#include <__ios/fpos.h> // expected-error@*:* {{use of private header from outside its module: '__ios/fpos.h'}}
+#include <__iterator/access.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/access.h'}}
+#include <__iterator/advance.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/advance.h'}}
+#include <__iterator/back_insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/back_insert_iterator.h'}}
+#include <__iterator/bounded_iter.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/bounded_iter.h'}}
+#include <__iterator/common_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/common_iterator.h'}}
+#include <__iterator/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts.h'}}
+#include <__iterator/counted_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/counted_iterator.h'}}
+#include <__iterator/data.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/data.h'}}
+#include <__iterator/default_sentinel.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/default_sentinel.h'}}
+#include <__iterator/distance.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/distance.h'}}
+#include <__iterator/empty.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/empty.h'}}
+#include <__iterator/erase_if_container.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/erase_if_container.h'}}
+#include <__iterator/front_insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/front_insert_iterator.h'}}
+#include <__iterator/incrementable_traits.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/incrementable_traits.h'}}
+#include <__iterator/indirectly_comparable.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/indirectly_comparable.h'}}
+#include <__iterator/insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/insert_iterator.h'}}
+#include <__iterator/istream_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/istream_iterator.h'}}
+#include <__iterator/istreambuf_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/istreambuf_iterator.h'}}
+#include <__iterator/iter_move.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/iter_move.h'}}
+#include <__iterator/iter_swap.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/iter_swap.h'}}
+#include <__iterator/iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/iterator.h'}}
+#include <__iterator/iterator_traits.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/iterator_traits.h'}}
+#include <__iterator/mergeable.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/mergeable.h'}}
+#include <__iterator/move_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/move_iterator.h'}}
+#include <__iterator/move_sentinel.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/move_sentinel.h'}}
+#include <__iterator/next.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/next.h'}}
+#include <__iterator/ostream_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/ostream_iterator.h'}}
+#include <__iterator/ostreambuf_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/ostreambuf_iterator.h'}}
+#include <__iterator/permutable.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/permutable.h'}}
+#include <__iterator/prev.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/prev.h'}}
+#include <__iterator/projected.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/projected.h'}}
+#include <__iterator/readable_traits.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/readable_traits.h'}}
+#include <__iterator/reverse_access.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/reverse_access.h'}}
+#include <__iterator/reverse_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/reverse_iterator.h'}}
+#include <__iterator/size.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/size.h'}}
+#include <__iterator/sortable.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/sortable.h'}}
+#include <__iterator/unreachable_sentinel.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/unreachable_sentinel.h'}}
+#include <__iterator/wrap_iter.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/wrap_iter.h'}}
+#include <__locale> // expected-error@*:* {{use of private header from outside its module: '__locale'}}
+#include <__mbstate_t.h> // expected-error@*:* {{use of private header from outside its module: '__mbstate_t.h'}}
+#include <__memory/addressof.h> // expected-error@*:* {{use of private header from outside its module: '__memory/addressof.h'}}
+#include <__memory/align.h> // expected-error@*:* {{use of private header from outside its module: '__memory/align.h'}}
+#include <__memory/allocate_at_least.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocate_at_least.h'}}
+#include <__memory/allocation_guard.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocation_guard.h'}}
+#include <__memory/allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator.h'}}
+#include <__memory/allocator_arg_t.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_arg_t.h'}}
+#include <__memory/allocator_destructor.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_destructor.h'}}
+#include <__memory/allocator_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_traits.h'}}
+#include <__memory/assume_aligned.h> // expected-error@*:* {{use of private header from outside its module: '__memory/assume_aligned.h'}}
+#include <__memory/auto_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/auto_ptr.h'}}
+#include <__memory/builtin_new_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/builtin_new_allocator.h'}}
+#include <__memory/compressed_pair.h> // expected-error@*:* {{use of private header from outside its module: '__memory/compressed_pair.h'}}
+#include <__memory/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__memory/concepts.h'}}
+#include <__memory/construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/construct_at.h'}}
+#include <__memory/destruct_n.h> // expected-error@*:* {{use of private header from outside its module: '__memory/destruct_n.h'}}
+#include <__memory/pointer_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/pointer_traits.h'}}
+#include <__memory/ranges_construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/ranges_construct_at.h'}}
+#include <__memory/ranges_uninitialized_algorithms.h> // expected-error@*:* {{use of private header from outside its module: '__memory/ranges_uninitialized_algorithms.h'}}
+#include <__memory/raw_storage_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/raw_storage_iterator.h'}}
+#include <__memory/shared_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/shared_ptr.h'}}
+#include <__memory/swap_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/swap_allocator.h'}}
+#include <__memory/temp_value.h> // expected-error@*:* {{use of private header from outside its module: '__memory/temp_value.h'}}
+#include <__memory/temporary_buffer.h> // expected-error@*:* {{use of private header from outside its module: '__memory/temporary_buffer.h'}}
+#include <__memory/uninitialized_algorithms.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uninitialized_algorithms.h'}}
+#include <__memory/unique_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/unique_ptr.h'}}
+#include <__memory/uses_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uses_allocator.h'}}
+#include <__memory/uses_allocator_construction.h> // expected-error@*:* {{use of private header from outside its module: '__memory/uses_allocator_construction.h'}}
+#include <__memory/voidify.h> // expected-error@*:* {{use of private header from outside its module: '__memory/voidify.h'}}
+#include <__memory_resource/memory_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/memory_resource.h'}}
+#include <__memory_resource/monotonic_buffer_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/monotonic_buffer_resource.h'}}
+#include <__memory_resource/polymorphic_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/polymorphic_allocator.h'}}
+#include <__memory_resource/pool_options.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/pool_options.h'}}
+#include <__memory_resource/synchronized_pool_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/synchronized_pool_resource.h'}}
+#include <__memory_resource/unsynchronized_pool_resource.h> // expected-error@*:* {{use of private header from outside its module: '__memory_resource/unsynchronized_pool_resource.h'}}
+#include <__mutex_base> // expected-error@*:* {{use of private header from outside its module: '__mutex_base'}}
+#include <__node_handle> // expected-error@*:* {{use of private header from outside its module: '__node_handle'}}
+#include <__numeric/accumulate.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/accumulate.h'}}
+#include <__numeric/adjacent_difference.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/adjacent_difference.h'}}
+#include <__numeric/exclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/exclusive_scan.h'}}
+#include <__numeric/gcd_lcm.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/gcd_lcm.h'}}
+#include <__numeric/inclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/inclusive_scan.h'}}
+#include <__numeric/inner_product.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/inner_product.h'}}
+#include <__numeric/iota.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/iota.h'}}
+#include <__numeric/midpoint.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/midpoint.h'}}
+#include <__numeric/partial_sum.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/partial_sum.h'}}
+#include <__numeric/reduce.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/reduce.h'}}
+#include <__numeric/transform_exclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/transform_exclusive_scan.h'}}
+#include <__numeric/transform_inclusive_scan.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/transform_inclusive_scan.h'}}
+#include <__numeric/transform_reduce.h> // expected-error@*:* {{use of private header from outside its module: '__numeric/transform_reduce.h'}}
+#include <__random/bernoulli_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/bernoulli_distribution.h'}}
+#include <__random/binomial_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/binomial_distribution.h'}}
+#include <__random/cauchy_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/cauchy_distribution.h'}}
+#include <__random/chi_squared_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/chi_squared_distribution.h'}}
+#include <__random/clamp_to_integral.h> // expected-error@*:* {{use of private header from outside its module: '__random/clamp_to_integral.h'}}
+#include <__random/default_random_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/default_random_engine.h'}}
+#include <__random/discard_block_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/discard_block_engine.h'}}
+#include <__random/discrete_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/discrete_distribution.h'}}
+#include <__random/exponential_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/exponential_distribution.h'}}
+#include <__random/extreme_value_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/extreme_value_distribution.h'}}
+#include <__random/fisher_f_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/fisher_f_distribution.h'}}
+#include <__random/gamma_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/gamma_distribution.h'}}
+#include <__random/generate_canonical.h> // expected-error@*:* {{use of private header from outside its module: '__random/generate_canonical.h'}}
+#include <__random/geometric_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/geometric_distribution.h'}}
+#include <__random/independent_bits_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/independent_bits_engine.h'}}
+#include <__random/is_seed_sequence.h> // expected-error@*:* {{use of private header from outside its module: '__random/is_seed_sequence.h'}}
+#include <__random/is_valid.h> // expected-error@*:* {{use of private header from outside its module: '__random/is_valid.h'}}
+#include <__random/knuth_b.h> // expected-error@*:* {{use of private header from outside its module: '__random/knuth_b.h'}}
+#include <__random/linear_congruential_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/linear_congruential_engine.h'}}
+#include <__random/log2.h> // expected-error@*:* {{use of private header from outside its module: '__random/log2.h'}}
+#include <__random/lognormal_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/lognormal_distribution.h'}}
+#include <__random/mersenne_twister_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/mersenne_twister_engine.h'}}
+#include <__random/negative_binomial_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/negative_binomial_distribution.h'}}
+#include <__random/normal_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/normal_distribution.h'}}
+#include <__random/piecewise_constant_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/piecewise_constant_distribution.h'}}
+#include <__random/piecewise_linear_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/piecewise_linear_distribution.h'}}
+#include <__random/poisson_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/poisson_distribution.h'}}
+#include <__random/random_device.h> // expected-error@*:* {{use of private header from outside its module: '__random/random_device.h'}}
+#include <__random/ranlux.h> // expected-error@*:* {{use of private header from outside its module: '__random/ranlux.h'}}
+#include <__random/seed_seq.h> // expected-error@*:* {{use of private header from outside its module: '__random/seed_seq.h'}}
+#include <__random/shuffle_order_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/shuffle_order_engine.h'}}
+#include <__random/student_t_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/student_t_distribution.h'}}
+#include <__random/subtract_with_carry_engine.h> // expected-error@*:* {{use of private header from outside its module: '__random/subtract_with_carry_engine.h'}}
+#include <__random/uniform_int_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_int_distribution.h'}}
+#include <__random/uniform_random_bit_generator.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_random_bit_generator.h'}}
+#include <__random/uniform_real_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/uniform_real_distribution.h'}}
+#include <__random/weibull_distribution.h> // expected-error@*:* {{use of private header from outside its module: '__random/weibull_distribution.h'}}
+#include <__ranges/access.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/access.h'}}
+#include <__ranges/all.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/all.h'}}
+#include <__ranges/common_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/common_view.h'}}
+#include <__ranges/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/concepts.h'}}
+#include <__ranges/copyable_box.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/copyable_box.h'}}
+#include <__ranges/counted.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/counted.h'}}
+#include <__ranges/dangling.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/dangling.h'}}
+#include <__ranges/data.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/data.h'}}
+#include <__ranges/drop_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_view.h'}}
+#include <__ranges/drop_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_while_view.h'}}
+#include <__ranges/empty.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/empty.h'}}
+#include <__ranges/empty_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/empty_view.h'}}
+#include <__ranges/enable_borrowed_range.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_borrowed_range.h'}}
+#include <__ranges/enable_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_view.h'}}
+#include <__ranges/filter_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/filter_view.h'}}
+#include <__ranges/iota_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/iota_view.h'}}
+#include <__ranges/istream_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/istream_view.h'}}
+#include <__ranges/join_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/join_view.h'}}
+#include <__ranges/lazy_split_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/lazy_split_view.h'}}
+#include <__ranges/non_propagating_cache.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/non_propagating_cache.h'}}
+#include <__ranges/owning_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/owning_view.h'}}
+#include <__ranges/range_adaptor.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/range_adaptor.h'}}
+#include <__ranges/rbegin.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/rbegin.h'}}
+#include <__ranges/ref_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/ref_view.h'}}
+#include <__ranges/rend.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/rend.h'}}
+#include <__ranges/reverse_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/reverse_view.h'}}
+#include <__ranges/single_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/single_view.h'}}
+#include <__ranges/size.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/size.h'}}
+#include <__ranges/subrange.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/subrange.h'}}
+#include <__ranges/take_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_view.h'}}
+#include <__ranges/take_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_while_view.h'}}
+#include <__ranges/transform_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/transform_view.h'}}
+#include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
+#include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
+#include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
+#include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
+#include <__std_stream> // expected-error@*:* {{use of private header from outside its module: '__std_stream'}}
+#include <__string/char_traits.h> // expected-error@*:* {{use of private header from outside its module: '__string/char_traits.h'}}
+#include <__string/extern_template_lists.h> // expected-error@*:* {{use of private header from outside its module: '__string/extern_template_lists.h'}}
+#include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
+#include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
+#include <__tuple/apply_cv.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/apply_cv.h'}}
+#include <__tuple/make_tuple_types.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/make_tuple_types.h'}}
+#include <__tuple/sfinae_helpers.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/sfinae_helpers.h'}}
+#include <__tuple/tuple_element.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_element.h'}}
+#include <__tuple/tuple_indices.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_indices.h'}}
+#include <__tuple/tuple_like.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_like.h'}}
+#include <__tuple/tuple_size.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_size.h'}}
+#include <__tuple/tuple_types.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_types.h'}}
+#include <__type_traits/add_const.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_const.h'}}
+#include <__type_traits/add_cv.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_cv.h'}}
+#include <__type_traits/add_lvalue_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_lvalue_reference.h'}}
+#include <__type_traits/add_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_pointer.h'}}
+#include <__type_traits/add_rvalue_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_rvalue_reference.h'}}
+#include <__type_traits/add_volatile.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_volatile.h'}}
+#include <__type_traits/aligned_storage.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/aligned_storage.h'}}
+#include <__type_traits/aligned_union.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/aligned_union.h'}}
+#include <__type_traits/alignment_of.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/alignment_of.h'}}
+#include <__type_traits/apply_cv.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/apply_cv.h'}}
+#include <__type_traits/can_extract_key.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/can_extract_key.h'}}
+#include <__type_traits/common_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/common_reference.h'}}
+#include <__type_traits/common_type.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/common_type.h'}}
+#include <__type_traits/conditional.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/conditional.h'}}
+#include <__type_traits/conjunction.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/conjunction.h'}}
+#include <__type_traits/copy_cv.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/copy_cv.h'}}
+#include <__type_traits/copy_cvref.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/copy_cvref.h'}}
+#include <__type_traits/decay.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/decay.h'}}
+#include <__type_traits/dependent_type.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/dependent_type.h'}}
+#include <__type_traits/disjunction.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/disjunction.h'}}
+#include <__type_traits/enable_if.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/enable_if.h'}}
+#include <__type_traits/extent.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/extent.h'}}
+#include <__type_traits/has_unique_object_representation.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/has_unique_object_representation.h'}}
+#include <__type_traits/has_virtual_destructor.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/has_virtual_destructor.h'}}
+#include <__type_traits/integral_constant.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/integral_constant.h'}}
+#include <__type_traits/is_abstract.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_abstract.h'}}
+#include <__type_traits/is_aggregate.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_aggregate.h'}}
+#include <__type_traits/is_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_allocator.h'}}
+#include <__type_traits/is_arithmetic.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_arithmetic.h'}}
+#include <__type_traits/is_array.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_array.h'}}
+#include <__type_traits/is_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_assignable.h'}}
+#include <__type_traits/is_base_of.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_base_of.h'}}
+#include <__type_traits/is_bounded_array.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_bounded_array.h'}}
+#include <__type_traits/is_callable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_callable.h'}}
+#include <__type_traits/is_char_like_type.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_char_like_type.h'}}
+#include <__type_traits/is_class.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_class.h'}}
+#include <__type_traits/is_compound.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_compound.h'}}
+#include <__type_traits/is_const.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_const.h'}}
+#include <__type_traits/is_constant_evaluated.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_constant_evaluated.h'}}
+#include <__type_traits/is_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_constructible.h'}}
+#include <__type_traits/is_convertible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_convertible.h'}}
+#include <__type_traits/is_copy_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_copy_assignable.h'}}
+#include <__type_traits/is_copy_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_copy_constructible.h'}}
+#include <__type_traits/is_core_convertible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_core_convertible.h'}}
+#include <__type_traits/is_default_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_default_constructible.h'}}
+#include <__type_traits/is_destructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_destructible.h'}}
+#include <__type_traits/is_empty.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_empty.h'}}
+#include <__type_traits/is_enum.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_enum.h'}}
+#include <__type_traits/is_final.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_final.h'}}
+#include <__type_traits/is_floating_point.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_floating_point.h'}}
+#include <__type_traits/is_function.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_function.h'}}
+#include <__type_traits/is_fundamental.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_fundamental.h'}}
+#include <__type_traits/is_implicitly_default_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_implicitly_default_constructible.h'}}
+#include <__type_traits/is_integral.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_integral.h'}}
+#include <__type_traits/is_literal_type.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_literal_type.h'}}
+#include <__type_traits/is_member_function_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_member_function_pointer.h'}}
+#include <__type_traits/is_member_object_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_member_object_pointer.h'}}
+#include <__type_traits/is_member_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_member_pointer.h'}}
+#include <__type_traits/is_move_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_move_assignable.h'}}
+#include <__type_traits/is_move_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_move_constructible.h'}}
+#include <__type_traits/is_nothrow_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_assignable.h'}}
+#include <__type_traits/is_nothrow_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_constructible.h'}}
+#include <__type_traits/is_nothrow_convertible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_convertible.h'}}
+#include <__type_traits/is_nothrow_copy_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_copy_assignable.h'}}
+#include <__type_traits/is_nothrow_copy_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_copy_constructible.h'}}
+#include <__type_traits/is_nothrow_default_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_default_constructible.h'}}
+#include <__type_traits/is_nothrow_destructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_destructible.h'}}
+#include <__type_traits/is_nothrow_move_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_move_assignable.h'}}
+#include <__type_traits/is_nothrow_move_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_nothrow_move_constructible.h'}}
+#include <__type_traits/is_null_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_null_pointer.h'}}
+#include <__type_traits/is_object.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_object.h'}}
+#include <__type_traits/is_pod.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_pod.h'}}
+#include <__type_traits/is_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_pointer.h'}}
+#include <__type_traits/is_polymorphic.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_polymorphic.h'}}
+#include <__type_traits/is_primary_template.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_primary_template.h'}}
+#include <__type_traits/is_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_reference.h'}}
+#include <__type_traits/is_reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_reference_wrapper.h'}}
+#include <__type_traits/is_referenceable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_referenceable.h'}}
+#include <__type_traits/is_same.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_same.h'}}
+#include <__type_traits/is_scalar.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_scalar.h'}}
+#include <__type_traits/is_scoped_enum.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_scoped_enum.h'}}
+#include <__type_traits/is_signed.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_signed.h'}}
+#include <__type_traits/is_signed_integer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_signed_integer.h'}}
+#include <__type_traits/is_specialization.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_specialization.h'}}
+#include <__type_traits/is_standard_layout.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_standard_layout.h'}}
+#include <__type_traits/is_swappable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_swappable.h'}}
+#include <__type_traits/is_trivial.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivial.h'}}
+#include <__type_traits/is_trivially_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_assignable.h'}}
+#include <__type_traits/is_trivially_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_constructible.h'}}
+#include <__type_traits/is_trivially_copy_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_copy_assignable.h'}}
+#include <__type_traits/is_trivially_copy_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_copy_constructible.h'}}
+#include <__type_traits/is_trivially_copyable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_copyable.h'}}
+#include <__type_traits/is_trivially_default_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_default_constructible.h'}}
+#include <__type_traits/is_trivially_destructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_destructible.h'}}
+#include <__type_traits/is_trivially_move_assignable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_move_assignable.h'}}
+#include <__type_traits/is_trivially_move_constructible.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_trivially_move_constructible.h'}}
+#include <__type_traits/is_unbounded_array.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_unbounded_array.h'}}
+#include <__type_traits/is_union.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_union.h'}}
+#include <__type_traits/is_unsigned.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_unsigned.h'}}
+#include <__type_traits/is_unsigned_integer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_unsigned_integer.h'}}
+#include <__type_traits/is_valid_expansion.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_valid_expansion.h'}}
+#include <__type_traits/is_void.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_void.h'}}
+#include <__type_traits/is_volatile.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_volatile.h'}}
+#include <__type_traits/lazy.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/lazy.h'}}
+#include <__type_traits/make_32_64_or_128_bit.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/make_32_64_or_128_bit.h'}}
+#include <__type_traits/make_const_lvalue_ref.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/make_const_lvalue_ref.h'}}
+#include <__type_traits/make_signed.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/make_signed.h'}}
+#include <__type_traits/make_unsigned.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/make_unsigned.h'}}
+#include <__type_traits/maybe_const.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/maybe_const.h'}}
+#include <__type_traits/nat.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/nat.h'}}
+#include <__type_traits/negation.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/negation.h'}}
+#include <__type_traits/noexcept_move_assign_container.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/noexcept_move_assign_container.h'}}
+#include <__type_traits/promote.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/promote.h'}}
+#include <__type_traits/rank.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/rank.h'}}
+#include <__type_traits/remove_all_extents.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_all_extents.h'}}
+#include <__type_traits/remove_const.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_const.h'}}
+#include <__type_traits/remove_const_ref.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_const_ref.h'}}
+#include <__type_traits/remove_cv.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_cv.h'}}
+#include <__type_traits/remove_cvref.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_cvref.h'}}
+#include <__type_traits/remove_extent.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_extent.h'}}
+#include <__type_traits/remove_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_pointer.h'}}
+#include <__type_traits/remove_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_reference.h'}}
+#include <__type_traits/remove_volatile.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/remove_volatile.h'}}
+#include <__type_traits/result_of.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/result_of.h'}}
+#include <__type_traits/strip_signature.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/strip_signature.h'}}
+#include <__type_traits/type_identity.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/type_identity.h'}}
+#include <__type_traits/type_list.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/type_list.h'}}
+#include <__type_traits/underlying_type.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/underlying_type.h'}}
+#include <__type_traits/void_t.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/void_t.h'}}
+#include <__utility/as_const.h> // expected-error@*:* {{use of private header from outside its module: '__utility/as_const.h'}}
+#include <__utility/auto_cast.h> // expected-error@*:* {{use of private header from outside its module: '__utility/auto_cast.h'}}
+#include <__utility/cmp.h> // expected-error@*:* {{use of private header from outside its module: '__utility/cmp.h'}}
+#include <__utility/convert_to_integral.h> // expected-error@*:* {{use of private header from outside its module: '__utility/convert_to_integral.h'}}
+#include <__utility/declval.h> // expected-error@*:* {{use of private header from outside its module: '__utility/declval.h'}}
+#include <__utility/exchange.h> // expected-error@*:* {{use of private header from outside its module: '__utility/exchange.h'}}
+#include <__utility/forward.h> // expected-error@*:* {{use of private header from outside its module: '__utility/forward.h'}}
+#include <__utility/forward_like.h> // expected-error@*:* {{use of private header from outside its module: '__utility/forward_like.h'}}
+#include <__utility/in_place.h> // expected-error@*:* {{use of private header from outside its module: '__utility/in_place.h'}}
+#include <__utility/integer_sequence.h> // expected-error@*:* {{use of private header from outside its module: '__utility/integer_sequence.h'}}
+#include <__utility/move.h> // expected-error@*:* {{use of private header from outside its module: '__utility/move.h'}}
+#include <__utility/pair.h> // expected-error@*:* {{use of private header from outside its module: '__utility/pair.h'}}
+#include <__utility/piecewise_construct.h> // expected-error@*:* {{use of private header from outside its module: '__utility/piecewise_construct.h'}}
+#include <__utility/priority_tag.h> // expected-error@*:* {{use of private header from outside its module: '__utility/priority_tag.h'}}
+#include <__utility/rel_ops.h> // expected-error@*:* {{use of private header from outside its module: '__utility/rel_ops.h'}}
+#include <__utility/small_buffer.h> // expected-error@*:* {{use of private header from outside its module: '__utility/small_buffer.h'}}
+#include <__utility/swap.h> // expected-error@*:* {{use of private header from outside its module: '__utility/swap.h'}}
+#include <__utility/to_underlying.h> // expected-error@*:* {{use of private header from outside its module: '__utility/to_underlying.h'}}
+#include <__utility/transaction.h> // expected-error@*:* {{use of private header from outside its module: '__utility/transaction.h'}}
+#include <__utility/unreachable.h> // expected-error@*:* {{use of private header from outside its module: '__utility/unreachable.h'}}
+#include <__variant/monostate.h> // expected-error@*:* {{use of private header from outside its module: '__variant/monostate.h'}}
+// GENERATED-MARKER
diff --git a/libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.move/assert.engaged.cpp b/libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.move/assert.engaged.cpp
new file mode 100644
index 0000000000000..910e83c625faa
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.move/assert.engaged.cpp
@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+#include <functional>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+ std::move_only_function<void()> func;
+ TEST_LIBCPP_ASSERT_FAILURE(func(), "Tried to call a disengaged move_only_function");
+}
diff --git a/libcxx/test/libcxx/utilities/pointer_int_pair.pass.cpp b/libcxx/test/libcxx/utilities/pointer_int_pair.pass.cpp
new file mode 100644
index 0000000000000..92013752ddcc8
--- /dev/null
+++ b/libcxx/test/libcxx/utilities/pointer_int_pair.pass.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include "test_macros.h"
+
+TEST_DIAGNOSTIC_PUSH
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wprivate-header")
+#include <__utility/pointer_int_pair.h>
+TEST_DIAGNOSTIC_POP
+
+#include <cassert>
+
+int main(int, char**) {
+ {
+ std::__pointer_int_pair<int*, 1> pair = nullptr;
+ assert(pair.__get_value() == 0);
+ assert(pair.__get_ptr() == nullptr);
+ }
+ {
+ std::__pointer_int_pair<int*, 1> pair(nullptr, 1);
+ assert(pair.__get_value() == 1);
+ assert(pair.__get_ptr() == nullptr);
+ }
+ {
+ static_assert(alignof(int) <= 4);
+ std::__pointer_int_pair<int*, 1> pair(reinterpret_cast<int*>(4), 0);
+ assert(pair.__get_value() == 0);
+ assert(pair.__get_ptr() == reinterpret_cast<int*>(4));
+ }
+}
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/functional.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/functional.version.compile.pass.cpp
index 27e76e5b2b05a..d4eb05f30495b 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/functional.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/functional.version.compile.pass.cpp
@@ -386,17 +386,11 @@
# error "__cpp_lib_invoke_r should have the value 202106L in c++23"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should be defined in c++23"
-# endif
-# if __cpp_lib_move_only_function != 202110L
-# error "__cpp_lib_move_only_function should have the value 202110L in c++23"
-# endif
-# else // _LIBCPP_VERSION
-# ifdef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_move_only_function
+# error "__cpp_lib_move_only_function should be defined in c++23"
+# endif
+# if __cpp_lib_move_only_function != 202110L
+# error "__cpp_lib_move_only_function should have the value 202110L in c++23"
# endif
# ifndef __cpp_lib_not_fn
@@ -508,17 +502,11 @@
# error "__cpp_lib_invoke_r should have the value 202106L in c++26"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should be defined in c++26"
-# endif
-# if __cpp_lib_move_only_function != 202110L
-# error "__cpp_lib_move_only_function should have the value 202110L in c++26"
-# endif
-# else // _LIBCPP_VERSION
-# ifdef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_move_only_function
+# error "__cpp_lib_move_only_function should be defined in c++26"
+# endif
+# if __cpp_lib_move_only_function != 202110L
+# error "__cpp_lib_move_only_function should have the value 202110L in c++26"
# endif
# ifndef __cpp_lib_not_fn
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
index c1e1f9f340af4..63d7fa8dd221e 100644
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp
@@ -5380,17 +5380,11 @@
# error "__cpp_lib_move_iterator_concept should have the value 202207L in c++23"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should be defined in c++23"
-# endif
-# if __cpp_lib_move_only_function != 202110L
-# error "__cpp_lib_move_only_function should have the value 202110L in c++23"
-# endif
-# else // _LIBCPP_VERSION
-# ifdef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_move_only_function
+# error "__cpp_lib_move_only_function should be defined in c++23"
+# endif
+# if __cpp_lib_move_only_function != 202110L
+# error "__cpp_lib_move_only_function should have the value 202110L in c++23"
# endif
# ifndef __cpp_lib_node_extract
@@ -7172,17 +7166,11 @@
# error "__cpp_lib_move_iterator_concept should have the value 202207L in c++26"
# endif
-# if !defined(_LIBCPP_VERSION)
-# ifndef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should be defined in c++26"
-# endif
-# if __cpp_lib_move_only_function != 202110L
-# error "__cpp_lib_move_only_function should have the value 202110L in c++26"
-# endif
-# else // _LIBCPP_VERSION
-# ifdef __cpp_lib_move_only_function
-# error "__cpp_lib_move_only_function should not be defined because it is unimplemented in libc++!"
-# endif
+# ifndef __cpp_lib_move_only_function
+# error "__cpp_lib_move_only_function should be defined in c++26"
+# endif
+# if __cpp_lib_move_only_function != 202110L
+# error "__cpp_lib_move_only_function should have the value 202110L in c++26"
# endif
# ifndef __cpp_lib_node_extract
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/functor.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/functor.pass.cpp
new file mode 100644
index 0000000000000..0598da573313b
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/functor.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ static_assert(!std::is_nothrow_assignable_v<std::move_only_function<T>&, NonTrivial>);
+ {
+ std::move_only_function<T> f;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = &call_func);
+ assert(&ret == &f);
+ assert(f);
+ }
+ {
+ std::move_only_function<T> f;
+ decltype(&call_func) ptr = nullptr;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = ptr);
+ assert(&ret == &f);
+ assert(!f);
+ }
+ {
+ std::move_only_function<T> f;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = TriviallyDestructible{});
+ assert(&ret == &f);
+ assert(f);
+ }
+ {
+ std::move_only_function<T> f;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = TriviallyDestructibleTooLarge{});
+ assert(&ret == &f);
+ assert(f);
+ }
+ {
+ std::move_only_function<T> f;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f = NonTrivial{});
+ assert(&ret == &f);
+ assert(f);
+ }
+}
+
+struct S {
+ void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+ {
+ std::move_only_function<T> f = &S::func;
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(!f2);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+ test_member_function_pointer<T>();
+ });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move.pass.cpp
new file mode 100644
index 0000000000000..1f17d991e8c4f
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move.pass.cpp
@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ static_assert(!std::is_assignable_v<std::move_only_function<T>, int>);
+ {
+ std::move_only_function<T> f = &call_func;
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(f2);
+ LIBCPP_ASSERT(!f);
+ }
+ {
+ decltype(&call_func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(!f2);
+ LIBCPP_ASSERT(!f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(f2);
+ LIBCPP_ASSERT(!f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(f2);
+ LIBCPP_ASSERT(!f);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(f2);
+ LIBCPP_ASSERT(!f);
+ }
+}
+
+struct S {
+ void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+ {
+ std::move_only_function<T> f = &S::func;
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(f2);
+ LIBCPP_ASSERT(!f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2;
+ f2 = std::move(f);
+ assert(!f2);
+ LIBCPP_ASSERT(!f);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+ test_member_function_pointer<T>();
+ });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move_other.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move_other.pass.cpp
new file mode 100644
index 0000000000000..b15e9337a1aaa
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/move_other.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <utility>
+
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ {
+ std::move_only_function<void() const noexcept> f1;
+ std::move_only_function<T> f2;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+ assert(&ret == &f2);
+ assert(!f2);
+ }
+ {
+ std::move_only_function<void() const & noexcept> f1;
+ std::move_only_function<T> f2;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+ assert(&ret == &f2);
+ assert(!f2);
+ }
+}
+
+template <class T>
+void test2() {
+ {
+ std::move_only_function<int() const noexcept> f1 = [] noexcept { return 109; };
+ std::move_only_function<T> f2;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+ assert(&ret == &f2);
+ assert(f2);
+ assert(f2() == 109);
+ }
+ {
+ std::move_only_function<int() const& noexcept> f1 = [] noexcept { return 109; };
+ std::move_only_function<T> f2;
+ std::same_as<std::move_only_function<T>&> decltype(auto) ret = (f2 = std::move(f1));
+ assert(&ret == &f2);
+ assert(f2);
+ assert(f2() == 109);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_lvalue_ref_qualified<int()>{}, []<class T> { test2<T>(); });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/nullptr.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/nullptr.pass.cpp
new file mode 100644
index 0000000000000..e32ace99f17f8
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/assignment/nullptr.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ {
+ std::move_only_function<T> f = &call_func;
+ f = nullptr;
+ assert(!f);
+ }
+ {
+ decltype(&call_func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ f = nullptr;
+ assert(!f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ f = nullptr;
+ assert(!f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ f = nullptr;
+ assert(!f);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ f = nullptr;
+ assert(!f);
+ }
+}
+
+struct S {
+ void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+ {
+ std::move_only_function<T> f = &S::func;
+ f = nullptr;
+ assert(!f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ f = nullptr;
+ assert(!f);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+ test_member_function_pointer<T>();
+ });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue.pass.cpp
new file mode 100644
index 0000000000000..0f50f827c4d2a
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() & {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() &>&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &>>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void()&> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S&)> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S&)> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void()&> f = CallTypeChecker{&type};
+ f();
+ assert(type == CallType::LValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int)&> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const.pass.cpp
new file mode 100644
index 0000000000000..82e2971fce287
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const.pass.cpp
@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() const& {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const&>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void() const&> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(const S&)> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(const S&)> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() const&> f = CallTypeChecker{&type};
+ f();
+ assert(type == CallType::ConstLValue);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() const&> f = CallTypeChecker{&type};
+ f();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::as_const(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(std::as_const(f))();
+ assert(type == CallType::ConstLValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int) const&> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const_noexcept.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const_noexcept.pass.cpp
new file mode 100644
index 0000000000000..d8129f541fc4f
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_const_noexcept.pass.cpp
@@ -0,0 +1,113 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() const& noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const & noexcept> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void() const& noexcept> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const& noexcept> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const& noexcept> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const& noexcept> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(const S&) noexcept> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(const S&) noexcept> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() const& noexcept> f = CallTypeCheckerNoexcept{&type};
+ f();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::as_const(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(std::as_const(f))();
+ assert(type == CallType::ConstLValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int) const& noexcept> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const& noexcept> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const& noexcept> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const& noexcept> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_noexcept.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_noexcept.pass.cpp
new file mode 100644
index 0000000000000..d14f527f812e1
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/lvalue_noexcept.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() & noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() & noexcept>&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept>>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() & noexcept> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void()& noexcept> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()& noexcept> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()& noexcept> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()& noexcept> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S&) noexcept> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S&) noexcept> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void()& noexcept> f = CallTypeCheckerNoexcept{&type};
+ f();
+ assert(type == CallType::LValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int)& noexcept> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)& noexcept> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)& noexcept> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)& noexcept> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal.pass.cpp
new file mode 100644
index 0000000000000..a1fe412efaa7f
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void()>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void()>>);
+static_assert(std::is_invocable_v<std::move_only_function<void()>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void()> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void()> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void()> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void()> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S)> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S)> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void()> f = CallTypeChecker{&type};
+ f();
+ assert(type == CallType::LValue);
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::LValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int)> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const.pass.cpp
new file mode 100644
index 0000000000000..8d7bc198b42ad
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const.pass.cpp
@@ -0,0 +1,112 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() const noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void() const> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S) const> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S) const> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() const> f = CallTypeChecker{&type};
+ f();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::as_const(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(std::as_const(f))();
+ assert(type == CallType::ConstLValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int) const> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const_noexcept.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const_noexcept.pass.cpp
new file mode 100644
index 0000000000000..1c0d18db15430
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_const_noexcept.pass.cpp
@@ -0,0 +1,112 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() const noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept>&&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const noexcept> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void() const noexcept> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const noexcept> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const noexcept> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const noexcept> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S) const noexcept> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S) const noexcept> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() const noexcept> f = CallTypeCheckerNoexcept{&type};
+ f();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::as_const(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::ConstLValue);
+ type = CallType::None;
+ std::move(std::as_const(f))();
+ assert(type == CallType::ConstLValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int) const noexcept> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const noexcept> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const noexcept> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const noexcept> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_noexcept.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_noexcept.pass.cpp
new file mode 100644
index 0000000000000..575bc27a35ab3
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/normal_noexcept.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() noexcept {}
+};
+
+static_assert(std::is_invocable_v<std::move_only_function<void() noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() noexcept> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() noexcept> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() noexcept> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void() noexcept> f = &call_func;
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() noexcept> f = TriviallyDestructible{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() noexcept> f = TriviallyDestructibleTooLarge{};
+ f();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() noexcept> f = NonTrivial{};
+ f();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S) noexcept> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S) noexcept> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() noexcept> f = CallTypeCheckerNoexcept{&type};
+ f();
+ assert(type == CallType::LValue);
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::LValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int) noexcept> f = &get_val;
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) noexcept> f = TriviallyDestructible{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) noexcept> f = TriviallyDestructibleTooLarge{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) noexcept> f = NonTrivial{};
+ assert(f(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue.pass.cpp
new file mode 100644
index 0000000000000..f51b48564dd33
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() && noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() &&>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() &&>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() &&> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void()&&> f = &call_func;
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&&> f = TriviallyDestructible{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&&> f = TriviallyDestructibleTooLarge{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&&> f = NonTrivial{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S)&&> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S)&&> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void()&&> f = CallTypeChecker{&type};
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::RValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int)&&> f = &get_val;
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&&> f = TriviallyDestructible{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&&> f = TriviallyDestructibleTooLarge{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&&> f = NonTrivial{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const.pass.cpp
new file mode 100644
index 0000000000000..fc664525d171a
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const.pass.cpp
@@ -0,0 +1,107 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() const&& noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() const&&>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() const&&> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const&&> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void() const&&> f = &call_func;
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&&> f = TriviallyDestructible{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&&> f = TriviallyDestructibleTooLarge{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&&> f = NonTrivial{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S) const&&> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S) const&&> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() const&&> f = CallTypeChecker{&type};
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::ConstRValue);
+ type = CallType::None;
+ std::move(std::as_const(f))();
+ assert(type == CallType::ConstRValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int) const&&> f = &get_val;
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&&> f = TriviallyDestructible{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&&> f = TriviallyDestructibleTooLarge{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&&> f = NonTrivial{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const_noexcept.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const_noexcept.pass.cpp
new file mode 100644
index 0000000000000..245b60eb45452
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_const_noexcept.pass.cpp
@@ -0,0 +1,107 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() const&& noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() const && noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() const && noexcept> const&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept> const >);
+static_assert(std::is_invocable_v<std::move_only_function<void() const && noexcept> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void() const&& noexcept> f = &call_func;
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&& noexcept> f = TriviallyDestructible{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&& noexcept> f = TriviallyDestructibleTooLarge{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void() const&& noexcept> f = NonTrivial{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S) const&& noexcept> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S) const&& noexcept> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void() const&& noexcept> f = CallTypeCheckerNoexcept{&type};
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::ConstRValue);
+ type = CallType::None;
+ std::move(std::as_const(f))();
+ assert(type == CallType::ConstRValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int) const&& noexcept> f = &get_val;
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&& noexcept> f = TriviallyDestructible{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&& noexcept> f = TriviallyDestructibleTooLarge{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int) const&& noexcept> f = NonTrivial{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_noexcept.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_noexcept.pass.cpp
new file mode 100644
index 0000000000000..87201aeec85cb
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/call/rvalue_noexcept.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "../common.h"
+
+struct S {
+ void func() && noexcept {}
+};
+
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept>&>);
+static_assert(std::is_invocable_v<std::move_only_function<void() && noexcept>>);
+static_assert(std::is_invocable_v<std::move_only_function<void() && noexcept>&&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept> const&>);
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept> const >);
+static_assert(!std::is_invocable_v<std::move_only_function<void() && noexcept> const&&>);
+
+void test() {
+ {
+ called = false;
+ std::move_only_function<void()&& noexcept> f = &call_func;
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&& noexcept> f = TriviallyDestructible{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&& noexcept> f = TriviallyDestructibleTooLarge{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ called = false;
+ std::move_only_function<void()&& noexcept> f = NonTrivial{};
+ std::move(f)();
+ assert(called);
+ }
+ {
+ std::move_only_function<void(S)&& noexcept> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<void(S)&& noexcept> f = ptr;
+ assert(!f);
+ }
+ {
+ CallType type;
+ std::move_only_function<void()&& noexcept> f = CallTypeCheckerNoexcept{&type};
+ type = CallType::None;
+ std::move(f)();
+ assert(type == CallType::RValue);
+ }
+}
+
+void test_return() {
+ {
+ called = false;
+ std::move_only_function<int(int)&& noexcept> f = &get_val;
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&& noexcept> f = TriviallyDestructible{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&& noexcept> f = TriviallyDestructibleTooLarge{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+ {
+ called = false;
+ std::move_only_function<int(int)&& noexcept> f = NonTrivial{};
+ assert(std::move(f)(3) == 3);
+ assert(!called);
+ }
+}
+
+int main(int, char**) {
+ test();
+ test_return();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/common.h b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/common.h
new file mode 100644
index 0000000000000..e0d82d9b00499
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/common.h
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MOVE_ONLY_FUNCTION_COMMON_H
+#define MOVE_ONLY_FUNCTION_COMMON_H
+
+#include <initializer_list>
+#include <type_traits>
+
+inline bool called;
+inline void call_func() noexcept { called = true; }
+
+struct MoveCounter {
+ int* counter_;
+ MoveCounter(int* counter) : counter_(counter) {}
+ MoveCounter(MoveCounter&& other) : counter_(other.counter_) { ++*counter_; }
+};
+
+struct TriviallyDestructible {
+ TriviallyDestructible() = default;
+ TriviallyDestructible(MoveCounter) {}
+ TriviallyDestructible(std::initializer_list<int>, MoveCounter) {}
+ void operator()() const noexcept { called = true; }
+ int operator()(int i) const noexcept { return i; }
+};
+
+struct TriviallyDestructibleTooLarge {
+ TriviallyDestructibleTooLarge() = default;
+ TriviallyDestructibleTooLarge(MoveCounter) {}
+ TriviallyDestructibleTooLarge(std::initializer_list<int>, MoveCounter) {}
+ void operator()() const noexcept { called = true; }
+ int operator()(int i) const noexcept { return i; }
+ char a[5 * sizeof(void*)];
+};
+
+struct NonTrivial {
+ NonTrivial() = default;
+ NonTrivial(MoveCounter) {}
+ NonTrivial(std::initializer_list<int>&, MoveCounter) {}
+ NonTrivial(NonTrivial&&) noexcept(false) {}
+ ~NonTrivial() {}
+
+ void operator()() const noexcept { called = true; }
+ int operator()(int i) const noexcept { return i; }
+};
+
+inline int get_val(int i) noexcept { return i; }
+
+enum class CallType {
+ None,
+ LValue,
+ RValue,
+ ConstLValue,
+ ConstRValue,
+};
+
+struct CallTypeChecker {
+ CallType* type;
+ using enum CallType;
+ void operator()() & { *type = LValue; }
+ void operator()() && { *type = RValue; }
+ void operator()() const& { *type = ConstLValue; }
+ void operator()() const&& { *type = ConstRValue; }
+};
+
+struct CallTypeCheckerNoexcept {
+ CallType* type;
+ using enum CallType;
+ void operator()() & noexcept { *type = LValue; }
+ void operator()() && noexcept { *type = RValue; }
+ void operator()() const& noexcept { *type = ConstLValue; }
+ void operator()() const&& noexcept { *type = ConstRValue; }
+};
+
+#endif // MOVE_ONLY_FUNCTION_COMMON_H
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/default.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/default.pass.cpp
new file mode 100644
index 0000000000000..d2490628a4bfc
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/default.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+
+template <class T>
+void test() {
+ std::move_only_function<T> f;
+ assert(!f);
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<int()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/functor.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/functor.pass.cpp
new file mode 100644
index 0000000000000..ef38e80159af8
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/functor.pass.cpp
@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "count_new.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ {
+ std::move_only_function<T> f = &call_func;
+ assert(f);
+ }
+ {
+ decltype(&call_func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ assert(!f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ assert(f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ assert(f);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ assert(f);
+ }
+}
+
+struct S {
+ void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+ {
+ std::move_only_function<T> f = &S::func;
+ assert(f);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ assert(!f);
+ }
+}
+
+template <class T>
+void test_value_return_type() {
+ {
+ std::move_only_function<T> f = &get_val;
+ assert(f);
+ }
+ {
+ decltype(&get_val) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ assert(!f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ assert(f);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ assert(f);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ assert(f);
+ }
+}
+
+template <class T>
+void test_throwing() {
+ struct ThrowingFunctor {
+ ThrowingFunctor() = default;
+ ThrowingFunctor(const ThrowingFunctor&) { throw 1; }
+ void operator()() {}
+ };
+ std::move_only_function<T> func({});
+}
+
+void check_new_delete_called() {
+ assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+ assert(globalMemCounter.new_array_called == globalMemCounter.delete_array_called);
+ assert(globalMemCounter.aligned_new_called == globalMemCounter.aligned_delete_called);
+ assert(globalMemCounter.aligned_new_array_called == globalMemCounter.aligned_delete_array_called);
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+ test_member_function_pointer<T>();
+ });
+ types::for_each(types::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> {
+ test_value_return_type<T>();
+ });
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test_throwing<T>(); });
+ check_new_delete_called();
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place.pass.cpp
new file mode 100644
index 0000000000000..9e415a9786633
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ {
+ int counter = 0;
+ std::move_only_function<T> f{std::in_place_type<TriviallyDestructible>, MoveCounter{&counter}};
+ assert(f);
+ assert(counter == 1);
+ }
+ {
+ int counter = 0;
+ std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleTooLarge>, MoveCounter{&counter}};
+ assert(f);
+ assert(counter == 1);
+ }
+ {
+ int counter = 0;
+ std::move_only_function<T> f{std::in_place_type<NonTrivial>, MoveCounter{&counter}};
+ assert(f);
+ assert(counter == 1);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place_init_list.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place_init_list.pass.cpp
new file mode 100644
index 0000000000000..46c16e24f5ffd
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/in_place_init_list.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ {
+ int counter = 0;
+ std::move_only_function<T> f{std::in_place_type<TriviallyDestructible>, {1}, MoveCounter{&counter}};
+ assert(f);
+ assert(counter == 1);
+ }
+ {
+ int counter = 0;
+ std::move_only_function<T> f{std::in_place_type<TriviallyDestructibleTooLarge>, {1}, MoveCounter{&counter}};
+ assert(f);
+ assert(counter == 1);
+ }
+ {
+ int counter = 0;
+ std::move_only_function<T> f{std::in_place_type<NonTrivial>, {1}, MoveCounter{&counter}};
+ assert(f);
+ assert(counter == 1);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move.pass.cpp
new file mode 100644
index 0000000000000..34688b252ab48
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+#include "../common.h"
+
+template <class T>
+void test() {
+ {
+ std::move_only_function<T> f = &call_func;
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ decltype(&call_func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2 = std::move(f);
+ assert(!f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+}
+
+struct S {
+ void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+ {
+ std::move_only_function<T> f = &S::func;
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2 = std::move(f);
+ assert(!f2);
+ }
+}
+
+template <class T>
+void test_value() {
+ {
+ std::move_only_function<T> f = &get_val;
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ decltype(&get_val) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2 = std::move(f);
+ assert(!f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ std::move_only_function<T> f2 = std::move(f);
+ assert(f2);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+ test_member_function_pointer<T>();
+ });
+ types::for_each(types::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test_value<T>(); });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move_other.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move_other.pass.cpp
new file mode 100644
index 0000000000000..805775579bd38
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/move_other.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+#include <utility>
+
+#include "type_algorithms.h"
+
+static_assert(!std::is_constructible_v<std::move_only_function<void() const>, std::move_only_function<void()>>);
+static_assert(!std::is_constructible_v<std::move_only_function<void() noexcept>, std::move_only_function<void()>>);
+static_assert(
+ !std::is_constructible_v<std::move_only_function<void() const noexcept>, std::move_only_function<void()>>);
+static_assert(
+ !std::is_constructible_v<std::move_only_function<void() const noexcept>, std::move_only_function<void() const>>);
+static_assert(
+ !std::is_constructible_v<std::move_only_function<void() const noexcept>, std::move_only_function<void() noexcept>>);
+
+template <class T>
+void test() {
+ {
+ std::move_only_function<void() const noexcept> f1;
+ std::move_only_function<T> f2 = std::move(f1);
+ assert(!f2);
+ }
+ {
+ std::move_only_function<void() const & noexcept> f1;
+ std::move_only_function<T> f2 = std::move(f1);
+ assert(!f2);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/nullptr.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/nullptr.pass.cpp
new file mode 100644
index 0000000000000..1ab95f271b4bc
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/ctors/nullptr.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+
+template <class T>
+void test() {
+ std::move_only_function<T> f = nullptr;
+ assert(!f);
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<int()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<int(int)>{}, []<class T> { test<T>(); });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.adl.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.adl.pass.cpp
new file mode 100644
index 0000000000000..d9200dfd3a1dc
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.adl.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+#include "common.h"
+
+template <class T>
+void test() {
+ {
+ std::move_only_function<T> f = &call_func;
+ std::move_only_function<T> f2;
+ swap(f, f2);
+ }
+ {
+ decltype(&call_func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2;
+ swap(f, f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ std::move_only_function<T> f2;
+ swap(f, f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ std::move_only_function<T> f2;
+ swap(f, f2);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ std::move_only_function<T> f2;
+ swap(f, f2);
+ }
+}
+
+struct S {
+ void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+ {
+ std::move_only_function<T> f = &S::func;
+ std::move_only_function<T> f2;
+ swap(f, f2);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2;
+ swap(f, f2);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+ test_member_function_pointer<T>();
+ });
+
+ return 0;
+}
diff --git a/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.member.pass.cpp b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.member.pass.cpp
new file mode 100644
index 0000000000000..b14769dcc1223
--- /dev/null
+++ b/libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.move/swap.member.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <functional>
+
+#include "type_algorithms.h"
+#include "common.h"
+
+template <class T>
+void test() {
+ {
+ std::move_only_function<T> f = &call_func;
+ std::move_only_function<T> f2;
+ f.swap(f2);
+ }
+ {
+ decltype(&call_func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2;
+ f.swap(f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructible{};
+ std::move_only_function<T> f2;
+ f.swap(f2);
+ }
+ {
+ std::move_only_function<T> f = TriviallyDestructibleTooLarge{};
+ std::move_only_function<T> f2;
+ f.swap(f2);
+ }
+ {
+ std::move_only_function<T> f = NonTrivial{};
+ std::move_only_function<T> f2;
+ f.swap(f2);
+ }
+}
+
+struct S {
+ void func() noexcept {}
+};
+
+template <class T>
+void test_member_function_pointer() {
+ {
+ std::move_only_function<T> f = &S::func;
+ std::move_only_function<T> f2;
+ f.swap(f2);
+ }
+ {
+ decltype(&S::func) ptr = nullptr;
+ std::move_only_function<T> f = ptr;
+ std::move_only_function<T> f2;
+ f.swap(f2);
+ }
+}
+
+int main(int, char**) {
+ types::for_each(types::function_noexcept_const_ref_qualified<void()>{}, []<class T> { test<T>(); });
+ types::for_each(types::function_noexcept_const_ref_qualified<void(S)>{}, []<class T> {
+ test_member_function_pointer<T>();
+ });
+
+ return 0;
+}
diff --git a/libcxx/test/support/type_algorithms.h b/libcxx/test/support/type_algorithms.h
index da3d0add4d0c4..b6f65ebb8d716 100644
--- a/libcxx/test/support/type_algorithms.h
+++ b/libcxx/test/support/type_algorithms.h
@@ -144,6 +144,42 @@ struct type_list_as_pointers<type_list<Types...> > {
template <class T>
using as_pointers = typename type_list_as_pointers<T>::type;
+template <class...>
+struct function_noexcept_const_lvalue_ref_qualified_impl;
+
+template <class ReturnT, class... Args>
+struct function_noexcept_const_lvalue_ref_qualified_impl<ReturnT(Args...)> {
+ using type =
+ type_list<ReturnT(Args...),
+ ReturnT(Args...)&,
+ ReturnT(Args...) noexcept,
+ ReturnT(Args...) & noexcept,
+ ReturnT(Args...) const,
+ ReturnT(Args...) const&,
+ ReturnT(Args...) const noexcept,
+ ReturnT(Args...) const & noexcept>;
+};
+
+template <class Func>
+using function_noexcept_const_lvalue_ref_qualified =
+ typename function_noexcept_const_lvalue_ref_qualified_impl<Func>::type;
+
+template <class...>
+struct function_noexcept_const_ref_qualified_impl;
+
+template <class ReturnT, class... Args>
+struct function_noexcept_const_ref_qualified_impl<ReturnT(Args...)> {
+ using type =
+ concatenate_t<function_noexcept_const_lvalue_ref_qualified<ReturnT(Args...)>,
+ type_list<ReturnT(Args...)&&,
+ ReturnT(Args...) && noexcept,
+ ReturnT(Args...) const&&,
+ ReturnT(Args...) const && noexcept> >;
+};
+
+template <class Func>
+using function_noexcept_const_ref_qualified = typename function_noexcept_const_ref_qualified_impl<Func>::type;
+
} // namespace types
#endif // TEST_SUPPORT_TYPE_ALGORITHMS_H
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
index 490ecefc97522..7220b91abfbfd 100755
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -867,7 +867,6 @@ def add_version_header(tc):
"name": "__cpp_lib_move_only_function",
"values": {"c++23": 202110},
"headers": ["functional"],
- "unimplemented": True,
},
{
"name": "__cpp_lib_node_extract",
More information about the libcxx-commits
mailing list