[libc++] Granularize the rest of memory

[philnik]

• generate files

[philnik]

• Try to fix CI

[philnik]

• Try to fix CI

[ldionne]

LGTM, thanks for the cleanup! I would also remove the "and remove transitive includes" from the commit message, since it does not really remove any user visible transitive includes.

libcxx/include/__memory/destruct_n.h

24

Side comment -- in a separate patch, let's investigate this. There really shouldn't be any logic in here, we should just call std::destroy_n. That should handle trivially destructible types and all.

This seems to be used as a RAII cleanup in some algorithms.

libcxx/include/algorithm

1900–1901

I think this needs to be rebased, since I would expect a check for && C++ <= 20 here (or something like that).

libcxx/include/memory

880–884

&& C++ <= 20?

[paulkirth]

Hi, I'm pretty sure we see a breakage in the llvm-libc++-static.cfg.in :: libcxx/transitive_includes.sh.cpp test due to this patch in Fuchsia's Clang CI.

Is it possible to take a look? I don't see an obvious reason we see this on x64 linux, but not other platforms, so maybe there's just something missed in the preprocessor directives?

The failing bot can be found here: https://ci.chromium.org/ui/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8804103688804713457/overview

[vitalybuka]

Reverting, breaks:
https://lab.llvm.org/buildbot/#/builders/238/builds/76
https://lab.llvm.org/buildbot/#/builders/237/builds/67
https://lab.llvm.org/buildbot/#/builders/236/builds/162
https://lab.llvm.org/buildbot/#/builders/239/builds/105
https://lab.llvm.org/buildbot/#/builders/5/builds/27199
https://lab.llvm.org/buildbot/#/builders/85/builds/10437
https://lab.llvm.org/buildbot/#/builders/74/builds/13281

[philnik]

• Fix transitive_includes test

[philnik]

• Try to fix CI

[philnik]

• Try to fix CI

[philnik]

• Add <memory> include to <functional>

[philnik]

• Next try

[philnik]

• Next try

[philnik]

• next try

[philnik]

• Another try

libcxx/include/CMakeLists.txt

set(files
   __iterator/reverse_iterator.h
   __iterator/size.h
   __iterator/sortable.h
   __iterator/unreachable_sentinel.h
   __iterator/wrap_iter.h
   __locale
   __mbstate_t.h
   __memory/addressof.h
+  __memory/align.h
   __memory/allocate_at_least.h
   __memory/allocation_guard.h
   __memory/allocator.h
   __memory/allocator_arg_t.h
   __memory/allocator_traits.h
   __memory/assume_aligned.h
   __memory/auto_ptr.h
+  __memory/builtin_new_allocator.h
   __memory/compressed_pair.h
   __memory/concepts.h
   __memory/construct_at.h
+  __memory/destruct_n.h
   __memory/pointer_traits.h
   __memory/ranges_construct_at.h
   __memory/ranges_uninitialized_algorithms.h
   __memory/raw_storage_iterator.h
   __memory/shared_ptr.h
   __memory/swap_allocator.h
+  __memory/temp_value.h
   __memory/temporary_buffer.h
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __memory/uses_allocator.h
   __memory/voidify.h
   __mutex_base
   __node_handle
   __numeric/accumulate.h
set(files
   __type_traits/disjunction.h
   __type_traits/enable_if.h
   __type_traits/extent.h
   __type_traits/has_unique_object_representation.h
   __type_traits/has_virtual_destructor.h
   __type_traits/integral_constant.h
   __type_traits/is_abstract.h
   __type_traits/is_aggregate.h
+  __type_traits/is_allocator.h
   __type_traits/is_arithmetic.h
   __type_traits/is_array.h
   __type_traits/is_assignable.h
   __type_traits/is_base_of.h
   __type_traits/is_bounded_array.h
   __type_traits/is_callable.h
   __type_traits/is_char_like_type.h
   __type_traits/is_class.h
set(files
   __type_traits/lazy.h
   __type_traits/make_32_64_or_128_bit.h
   __type_traits/make_const_lvalue_ref.h
   __type_traits/make_signed.h
   __type_traits/make_unsigned.h
   __type_traits/maybe_const.h
   __type_traits/nat.h
   __type_traits/negation.h
+  __type_traits/noexcept_move_assign_container.h
   __type_traits/promote.h
   __type_traits/rank.h
   __type_traits/remove_all_extents.h
   __type_traits/remove_const.h
   __type_traits/remove_const_ref.h
   __type_traits/remove_cv.h
   __type_traits/remove_cvref.h
   __type_traits/remove_extent.h

libcxx/include/__algorithm/inplace_merge.h

 #include <__algorithm/rotate.h>
 #include <__algorithm/upper_bound.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__iterator/advance.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
-#include <memory>
+#include <__memory/destruct_n.h>
+#include <__memory/temporary_buffer.h>
+#include <__memory/unique_ptr.h>
+#include <__utility/pair.h>
+#include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__algorithm/ranges_copy.h

 #include <__algorithm/in_out_result.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__iterator/concepts.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_equal_range.h

 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/subrange.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_find_end.h

 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/subrange.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_minmax.h

 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 

libcxx/include/__algorithm/ranges_next_permutation.h

 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/sortable.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_partial_sort.h

 #include <__iterator/next.h>
 #include <__iterator/projected.h>
 #include <__iterator/sortable.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_partial_sort_copy.h

 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__iterator/sortable.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_partition.h

 #include <__iterator/iterator_traits.h>
 #include <__iterator/permutable.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/subrange.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 

libcxx/include/__algorithm/ranges_prev_permutation.h

 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/sortable.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_search.h

 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/distance.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_search_n.h

 #include <__iterator/incrementable_traits.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_set_difference.h

 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/mergeable.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__type_traits/decay.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_unique.h

 #include <__iterator/permutable.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/subrange.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/ranges_unique_copy.h

 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/set_symmetric_difference.h

 #define _LIBCPP___ALGORITHM_SET_SYMMETRIC_DIFFERENCE_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/copy.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InIter1, class _InIter2, class _OutIter>

libcxx/include/__algorithm/set_union.h

 #define _LIBCPP___ALGORITHM_SET_UNION_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/copy.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InIter1, class _InIter2, class _OutIter>

libcxx/include/__algorithm/sort.h

 #include <__algorithm/unwrap_iter.h>
 #include <__bits>
 #include <__config>
 #include <__debug>
 #include <__debug_utils/randomize_range.h>
 #include <__functional/operations.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/iterator_traits.h>
+#include <__memory/destruct_n.h>
+#include <__memory/unique_ptr.h>
 #include <climits>
-#include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Wraps an algorithm policy tag and a comparator in a single struct, used to pass the policy tag around without

libcxx/include/__algorithm/stable_partition.h

 #define _LIBCPP___ALGORITHM_STABLE_PARTITION_H
 
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/rotate.h>
 #include <__config>
 #include <__iterator/advance.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
-#include <memory>
+#include <__memory/destruct_n.h>
+#include <__memory/temporary_buffer.h>
+#include <__memory/unique_ptr.h>
+#include <__utility/pair.h>
+#include <new>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__algorithm/stable_sort.h

 
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/inplace_merge.h>
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/sort.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__memory/destruct_n.h>
+#include <__memory/temporary_buffer.h>
+#include <__memory/unique_ptr.h>
 #include <__utility/move.h>
-#include <memory>
+#include <__utility/pair.h>
+#include <new>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__bsd_locale_fallbacks.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // The BSDs have lots of *_l functions.  This file provides reimplementations
 // of those functions for non-BSD platforms.
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___BSD_LOCALE_FALLBACKS_H
 #define _LIBCPP___BSD_LOCALE_FALLBACKS_H
 
-#include <memory>
 #include <stdarg.h>
 #include <stdlib.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__filesystem/filesystem_error.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
 #define _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
 
 #include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <__memory/shared_ptr.h>
+#include <__utility/forward.h>
 #include <iosfwd>
 #include <new>
 #include <system_error>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__format/format_arg_store.h

 #  pragma GCC system_header
 #endif
 
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_arg.h>
+#include <__utility/forward.h>
 #include <cstring>
 #include <string>
 #include <string_view>
 #include <type_traits>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__functional/function.h

 
 #include <__assert>
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
+#include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
+#include <__memory/builtin_new_allocator.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <exception>
-#include <memory> // TODO: replace with <__memory/__builtin_new_allocator.h>
+#include <tuple>
 #include <type_traits>
+#include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // bad_function_call

libcxx/include/__hash_table

 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <__functional/hash.h>
 #include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
 #include <__type_traits/can_extract_key.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <cmath>
+#include <cstring>
 #include <initializer_list>
-#include <memory>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__locale

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___LOCALE
 #define _LIBCPP___LOCALE
 
 #include <__availability>
 #include <__config>
+#include <__memory/shared_ptr.h>
 #include <cctype>
 #include <cstdint>
 #include <locale.h>
-#include <memory>
 #include <mutex>
 #include <string>
 
 #if defined(_LIBCPP_MSVCRT_LIKE)
 # include <__support/win32/locale_win32.h>
 # include <cstring>
 #elif defined(_AIX) || defined(__MVS__)
 # include <__support/ibm/xlocale.h>

libcxx/include/__memory/align.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_ALIGN_H
+#define _LIBCPP___MEMORY_ALIGN_H
+
+#include <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_ALIGN_H

libcxx/include/__memory/builtin_new_allocator.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_BUILTIN_NEW_ALLOCATOR_H
+#define _LIBCPP___MEMORY_BUILTIN_NEW_ALLOCATOR_H
+
+#include <__config>
+#include <__memory/unique_ptr.h>
+#include <cstddef>
+#include <new>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// __builtin_new_allocator -- A non-templated helper for allocating and
+// deallocating memory using __builtin_operator_new and
+// __builtin_operator_delete. It should be used in preference to
+// `std::allocator<T>` to avoid additional instantiations.
+struct __builtin_new_allocator {
+  struct __builtin_new_deleter {
+    typedef void* pointer_type;
+
+    _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
+        : __size_(__size), __align_(__align) {}
+
+    void operator()(void* __p) const _NOEXCEPT {
+        _VSTD::__libcpp_deallocate(__p, __size_, __align_);
+    }
+
+   private:
+    size_t __size_;
+    size_t __align_;
+  };
+
+  typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
+
+  static __holder_t __allocate_bytes(size_t __s, size_t __align) {
+      return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
+                     __builtin_new_deleter(__s, __align));
+  }
+
+  static void __deallocate_bytes(void* __p, size_t __s,
+                                 size_t __align) _NOEXCEPT {
+      _VSTD::__libcpp_deallocate(__p, __s, __align);
+  }
+
+  template <class _Tp>
+  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
+  static __holder_t __allocate_type(size_t __n) {
+      return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+  }
+
+  template <class _Tp>
+  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
+  static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
+      __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+  }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_BUILTIN_NEW_ALLOCATOR_H

libcxx/include/__memory/construct_at.h

 
 #include <__assert>
 #include <__config>
 #include <__iterator/access.h>
 #include <__memory/addressof.h>
 #include <__memory/voidify.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <new>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__memory/destruct_n.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_DESTRUCT_N_H
+#define _LIBCPP___MEMORY_DESTRUCT_N_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __destruct_n
+{
+private:
+    size_t __size_;
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
+        {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
+        {++__size_;}
+    _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
+        {__size_ = __s;}
+    _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
+        {}
+public:
+    _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
+        : __size_(__s) {}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __incr() _NOEXCEPT
+        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
+        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
+        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_DESTRUCT_N_H

libcxx/include/__memory/ranges_construct_at.h

 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__memory/ranges_uninitialized_algorithms.h

 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/concepts.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
+#include <new>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__memory/raw_storage_iterator.h

 #define _LIBCPP___MEMORY_RAW_STORAGE_ITERATOR_H
 
 #include <__config>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__utility/move.h>
 #include <cstddef>
+#include <new>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR)

libcxx/include/__memory/shared_ptr.h

 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
+#include <new>
 #include <stdexcept>
 #include <type_traits>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
 
 

libcxx/include/__memory/temp_value.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_TEMP_VALUE_H
+#define _LIBCPP___MEMORY_TEMP_VALUE_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/allocator_traits.h>
+#include <__type_traits/aligned_storage.h>
+#include <__utility/forward.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Alloc>
+struct __temp_value {
+    typedef allocator_traits<_Alloc> _Traits;
+
+#ifdef _LIBCPP_CXX03_LANG
+    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
+#else
+    union { _Tp __v; };
+#endif
+    _Alloc &__a;
+
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp *__addr() {
+#ifdef _LIBCPP_CXX03_LANG
+        return reinterpret_cast<_Tp*>(std::addressof(__v));
+#else
+        return std::addressof(__v);
+#endif
+    }
+
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp &   get() { return *__addr(); }
+
+    template<class... _Args>
+    _LIBCPP_NO_CFI
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
+      _Traits::construct(__a, __addr(), std::forward<_Args>(__args)...);
+    }
+
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__temp_value() { _Traits::destroy(__a, __addr()); }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_TEMP_VALUE_H

libcxx/include/__memory/uninitialized_algorithms.h

 #include <__memory/allocator_traits.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/voidify.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/transaction.h>
+#include <new>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__node_handle

friend void swap(node-handle& x, node-handle& y) noexcept(noexcept(x.swap(y))) {
     x.swap(y);
   }
 };
 
 */
 
 #include <__assert>
 #include <__config>
-#include <memory>
+#include <__memory/allocator_traits.h>
+#include <__memory/pointer_traits.h>
 #include <optional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__split_buffer

 
 #include <__algorithm/max.h>
 #include <__algorithm/move.h>
 #include <__algorithm/move_backward.h>
 #include <__config>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
+#include <__memory/allocate_at_least.h>
 #include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
 #include <__memory/swap_allocator.h>
 #include <__utility/forward.h>
-#include <memory>
+#include <__utility/move.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__tree

 
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__config>
 #include <__debug>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
 #include <__type_traits/can_extract_key.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <limits>
-#include <memory>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__type_traits/is_allocator.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_IS_ALLOCATOR_H
+#define _LIBCPP___TYPE_IS_ALLOCATOR_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<typename _Alloc, typename = void, typename = void>
+struct __is_allocator : false_type {};
+
+template<typename _Alloc>
+struct __is_allocator<_Alloc,
+       typename __void_t<typename _Alloc::value_type>::type,
+       typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type
+     >
+   : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_IS_ALLOCATOR_H

libcxx/include/__type_traits/noexcept_move_assign_container.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H
+#define _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H
+
+#include <__config>
+#include <__memory/allocator_traits.h>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
+struct __noexcept_move_assign_container : public integral_constant<bool,
+    _Traits::propagate_on_container_move_assignment::value
+#if _LIBCPP_STD_VER > 14
+        || _Traits::is_always_equal::value
+#else
+        && is_nothrow_move_assignable<_Alloc>::value
+#endif
+    > {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H

libcxx/include/algorithm

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bits>
 #include <__config>
 #include <__debug>
 #include <cstddef>
 #include <cstring>
-#include <memory>
 #include <type_traits>
 #include <version>
 
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/all_of.h>
 #include <__algorithm/any_of.h>
 #include <__algorithm/binary_search.h>
 #include <__algorithm/clamp.h>

 #include <__algorithm/stable_partition.h>
 #include <__algorithm/stable_sort.h>
 #include <__algorithm/swap_ranges.h>
 #include <__algorithm/transform.h>
 #include <__algorithm/unique.h>
 #include <__algorithm/unique_copy.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__algorithm/upper_bound.h>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono> // IGNORE-CYCLE due to <format>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
+#  include <chrono>
 #  include <iterator>
+#  include <memory>
+#  include <stdexcept>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
-#   include <__pstl_algorithm>
+#  include <__pstl_algorithm>
 #endif
 
 #endif // _LIBCPP_ALGORITHM

libcxx/include/any

 
 } // namespace std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstdlib>
 #include <initializer_list>
-#include <memory>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono> // IGNORE-CYCLE due to <format>
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <chrono>
+#  include <iterator>
+#  include <memory>
+#  include <variant>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 namespace std {
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
 {
 public:

libcxx/include/barrier

 
 }
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
+#include <__memory/unique_ptr.h>
 #include <__thread/timed_backoff_policy.h>
+#include <__utility/move.h>
 #include <atomic>
 #include <limits>
-#include <memory>
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <concepts>
+#  include <iterator>
+#  include <memory>
+#  include <stdexcept>
+#  include <variant>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error "<barrier> is not supported since libc++ has been configured without support for threads."
 #endif

libcxx/include/condition_variable

 };
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
 #include <__mutex_base>
-#include <memory>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 

libcxx/include/deque

 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__format/enable_insertable.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/temp_value.h>
+#include <__memory/unique_ptr.h>
 #include <__split_buffer>
+#include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 

libcxx/include/experimental/coroutine

 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <cstddef>
 #include <experimental/__config>
-#include <memory> // for hash<T*>
 #include <new>
 #include <type_traits>
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
+#  include <chrono>
+#  include <climits>
+#  include <cmath>
+#  include <compare>
+#  include <concepts>
+#  include <ctime>
+#  include <initializer_list>
+#  include <iosfwd>
+#  include <iterator>
+#  include <memory>
+#  include <ratio>
+#  include <stdexcept>
+#  include <tuple>
+#  include <typeinfo>
+#  include <utility>
+#  include <variant>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
 
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
 

libcxx/include/experimental/memory_resource

 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
+#include <__memory/allocator_traits.h>
 #include <__tuple>
 #include <__utility/move.h>
 #include <cstddef>
 #include <cstdlib>
 #include <experimental/__config>
 #include <experimental/__memory>
 #include <limits>
-#include <memory>
 #include <new>
 #include <stdexcept>
+#include <tuple>
 #include <type_traits>
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
+#  include <chrono>
+#  include <climits>
+#  include <concepts>
+#  include <cstring>
+#  include <ctime>
+#  include <iterator>
+#  include <memory>
+#  include <ratio>
+#  include <variant>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR

libcxx/include/forward_list

 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
+#include <__memory/addressof.h>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
 #include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <limits>
-#include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #endif

libcxx/include/fstream

 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <istream>
 #include <ostream>
+#include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/functional

 #include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h> // TODO: deprecate
 #include <__functional/unary_negate.h>
 #include <__functional/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <concepts>
 #include <exception>
-#include <memory>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <utility>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

 #include <__chrono/time_point.h>
 #include <__config>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <exception>
-#include <memory>
 #include <mutex>
+#include <new>
 #include <system_error>
 #include <thread>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono> // IGNORE-CYCLE due to <format>
 #endif
 

libcxx/include/list

 #include <__debug>
 #include <__format/enable_insertable.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
+#include <__memory/addressof.h>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
 #include <__memory/swap_allocator.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <limits>
-#include <memory>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #endif

libcxx/include/locale

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__iterator/access.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
 #include <__locale>
+#include <__memory/unique_ptr.h>
 #include <cstdarg> // TODO: Remove this include
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <ios>
 #include <limits>
-#include <memory>
+#include <new>
 #include <streambuf>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #endif
 
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))

libcxx/include/map

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
+#include <__memory/allocator.h>
 #include <__node_handle>
 #include <__tree>
+#include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
+#include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
-#include <memory>
+#include <tuple>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #  include <utility>
 #endif

libcxx/include/memory

 
 template<size_t N, class T>
 [[nodiscard]] constexpr T* assume_aligned(T* ptr); // since C++20
 
 }  // std
 
 */
 
-#include <__algorithm/copy.h>
-#include <__algorithm/move.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/addressof.h>
+#include <__memory/align.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/assume_aligned.h>
 #include <__memory/auto_ptr.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/ranges_construct_at.h>
 #include <__memory/ranges_uninitialized_algorithms.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iosfwd>
-#include <new>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
-#include <typeinfo>
-#include <version>
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <iterator>
+#include <version>
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstddef>
+#  include <cstdint>
+#  include <cstring>
+#  include <iosfwd>
+#  include <iterator>
+#  include <new>
+#  include <stdexcept>
+#  include <tuple>
+#  include <type_traits>
+#  include <typeinfo>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-struct __destruct_n
-{
-private:
-    size_t __size_;
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
-        {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
-        {}
-
-    _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
-        {++__size_;}
-    _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
-        {}
-
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
-        {__size_ = __s;}
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
-        {}
-public:
-    _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
-        : __size_(__s) {}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __incr() _NOEXCEPT
-        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
-        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
-        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-};
-
-_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
-
-template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
-struct __noexcept_move_assign_container : public integral_constant<bool,
-    _Traits::propagate_on_container_move_assignment::value
-#if _LIBCPP_STD_VER > 14
-        || _Traits::is_always_equal::value
-#else
-        && is_nothrow_move_assignable<_Alloc>::value
-#endif
-    > {};
-
-
-template <class _Tp, class _Alloc>
-struct __temp_value {
-    typedef allocator_traits<_Alloc> _Traits;
-
-#ifdef _LIBCPP_CXX03_LANG
-    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
-#else
-    union { _Tp __v; };
-#endif
-    _Alloc &__a;
-
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp *__addr() {
-#ifdef _LIBCPP_CXX03_LANG
-        return reinterpret_cast<_Tp*>(std::addressof(__v));
-#else
-        return std::addressof(__v);
-#endif
-    }
-
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp &   get() { return *__addr(); }
-
-    template<class... _Args>
-    _LIBCPP_NO_CFI
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
-      _Traits::construct(__a, __addr(), std::forward<_Args>(__args)...);
-    }
-
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__temp_value() { _Traits::destroy(__a, __addr()); }
-};
-
-template<typename _Alloc, typename = void, typename = void>
-struct __is_allocator : false_type {};
-
-template<typename _Alloc>
-struct __is_allocator<_Alloc,
-       typename __void_t<typename _Alloc::value_type>::type,
-       typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type
-     >
-   : true_type {};
-
-// __builtin_new_allocator -- A non-templated helper for allocating and
-// deallocating memory using __builtin_operator_new and
-// __builtin_operator_delete. It should be used in preference to
-// `std::allocator<T>` to avoid additional instantiations.
-struct __builtin_new_allocator {
-  struct __builtin_new_deleter {
-    typedef void* pointer_type;
-
-    _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
-        : __size_(__size), __align_(__align) {}
-
-    void operator()(void* __p) const _NOEXCEPT {
-        _VSTD::__libcpp_deallocate(__p, __size_, __align_);
-    }
-
-   private:
-    size_t __size_;
-    size_t __align_;
-  };
-
-  typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
-
-  static __holder_t __allocate_bytes(size_t __s, size_t __align) {
-      return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
-                     __builtin_new_deleter(__s, __align));
-  }
-
-  static void __deallocate_bytes(void* __p, size_t __s,
-                                 size_t __align) _NOEXCEPT {
-      _VSTD::__libcpp_deallocate(__p, __s, __align);
-  }
-
-  template <class _Tp>
-  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
-  static __holder_t __allocate_type(size_t __n) {
-      return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
-  }
-
-  template <class _Tp>
-  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
-  static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
-      __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
-  }
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/include/module.modulemap.in

module map {
     export *
   }
   module memory {
     header "memory"
     export *
 
     module __memory {
       module addressof                       { private header "__memory/addressof.h" }
+      module align                           { private header "__memory/align.h" }
       module allocate_at_least               { private header "__memory/allocate_at_least.h" }
       module allocation_guard                { private header "__memory/allocation_guard.h" }
       module allocator                       { private header "__memory/allocator.h" }
       module allocator_arg_t                 { private header "__memory/allocator_arg_t.h" }
       module allocator_traits                { private header "__memory/allocator_traits.h" }
       module assume_aligned                  { private header "__memory/assume_aligned.h" }
       module auto_ptr                        { private header "__memory/auto_ptr.h" }
+      module builtin_new_allocator           { private header "__memory/builtin_new_allocator.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
       module concepts                        { private header "__memory/concepts.h" }
       module construct_at                    { private header "__memory/construct_at.h" }
+      module destruct_n                      { private header "__memory/destruct_n.h" }
       module pointer_traits                  { private header "__memory/pointer_traits.h" }
       module ranges_construct_at             { private header "__memory/ranges_construct_at.h" }
       module ranges_uninitialized_algorithms { private header "__memory/ranges_uninitialized_algorithms.h" }
       module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }
       module shared_ptr                      { private header "__memory/shared_ptr.h" }
       module swap_allocator                  { private header "__memory/swap_allocator.h" }
+      module temp_value                      { private header "__memory/temp_value.h" }
       module temporary_buffer                { private header "__memory/temporary_buffer.h" }
       module uninitialized_algorithms        { private header "__memory/uninitialized_algorithms.h" }
       module unique_ptr                      { private header "__memory/unique_ptr.h" }
       module uses_allocator                  { private header "__memory/uses_allocator.h" }
       module voidify                         { private header "__memory/voidify.h" }
     }
   }
   module mutex {
module type_traits {
     module disjunction                         { private header "__type_traits/disjunction.h" }
     module enable_if                           { private header "__type_traits/enable_if.h" }
     module extent                              { private header "__type_traits/extent.h" }
     module has_unique_object_representation    { private header "__type_traits/has_unique_object_representation.h" }
     module has_virtual_destructor              { private header "__type_traits/has_virtual_destructor.h" }
     module integral_constant                   { private header "__type_traits/integral_constant.h" }
     module is_abstract                         { private header "__type_traits/is_abstract.h" }
     module is_aggregate                        { private header "__type_traits/is_aggregate.h" }
+    module is_allocator                        { private header "__type_traits/is_allocator.h" }
     module is_arithmetic                       { private header "__type_traits/is_arithmetic.h" }
     module is_array                            { private header "__type_traits/is_array.h" }
     module is_assignable                       { private header "__type_traits/is_assignable.h" }
     module is_base_of                          { private header "__type_traits/is_base_of.h" }
     module is_bounded_array                    { private header "__type_traits/is_bounded_array.h" }
     module is_callable                         { private header "__type_traits/is_callable.h" }
     module is_char_like_type                   { private header "__type_traits/is_char_like_type.h" }
     module is_class                            { private header "__type_traits/is_class.h" }
module type_traits {
     module lazy                                { private header "__type_traits/lazy.h" }
     module make_32_64_or_128_bit               { private header "__type_traits/make_32_64_or_128_bit.h" }
     module make_const_lvalue_ref               { private header "__type_traits/make_const_lvalue_ref.h" }
     module make_signed                         { private header "__type_traits/make_signed.h" }
     module make_unsigned                       { private header "__type_traits/make_unsigned.h" }
     module maybe_const                         { private header "__type_traits/maybe_const.h" }
     module nat                                 { private header "__type_traits/nat.h" }
     module negation                            { private header "__type_traits/negation.h" }
+    module noexcept_move_assign_container      { private header "__type_traits/noexcept_move_assign_container.h" }
     module promote                             { private header "__type_traits/promote.h" }
     module rank                                { private header "__type_traits/rank.h" }
     module remove_all_extents                  { private header "__type_traits/remove_all_extents.h" }
     module remove_const                        { private header "__type_traits/remove_const.h" }
     module remove_const_ref                    { private header "__type_traits/remove_const_ref.h" }
     module remove_cv                           { private header "__type_traits/remove_cv.h" }
     module remove_cvref                        { private header "__type_traits/remove_cvref.h" }
     module remove_extent                       { private header "__type_traits/remove_extent.h" }

libcxx/include/mutex

template<class Callable, class ...Args>
   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__memory/shared_ptr.h>
 #include <__mutex_base>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstdint>
-#include <memory>
 #ifndef _LIBCPP_CXX03_LANG
 # include <tuple>
 #endif
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #endif

libcxx/include/ostream

 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__memory/unique_ptr.h>
 #include <bitset>
 #include <ios>
 #include <locale>
+#include <new>
 #include <streambuf>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/queue

 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <deque>
 #include <type_traits>
 #include <vector>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #endif
 
 // standard-mandated includes
 #include <compare>
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/regex

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <deque>
-#include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #  include <utility>

libcxx/include/scoped_allocator

operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__memory/allocator_traits.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/remove_reference.h>
 #include <__utility/forward.h>
-#include <memory>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <__utility/piecewise_construct.h>
+#include <tuple>
 #include <version>
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
+#  include <chrono>
+#  include <climits>
+#  include <concepts>
+#  include <cstring>
+#  include <ctime>
+#  include <iterator>
+#  include <memory>
+#  include <ratio>
+#  include <stdexcept>
+#  include <variant>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_CXX03_LANG)
 

libcxx/include/set

 #include <__algorithm/lexicographical_compare.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
+#include <__memory/allocator.h>
 #include <__node_handle>
 #include <__tree>
+#include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #endif
 

libcxx/include/string

 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__ios/fpos.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
+#include <__memory/allocator.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
+#include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
+#include <__type_traits/is_allocator.h>
+#include <__type_traits/noexcept_move_assign_container.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <cstdint>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <iosfwd>
 #include <limits>
-#include <memory>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif

libcxx/include/thread

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/hash.h>
+#include <__memory/unique_ptr.h>
 #include <__mutex_base>
 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstddef>
 #include <iosfwd>
-#include <memory>
 #include <system_error>
 #include <tuple>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono> // IGNORE-CYCLE due to <format>
 #endif

libcxx/include/unordered_map

 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
+#include <__memory/allocator.h>
 #include <__node_handle>
+#include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <stdexcept>
 #include <tuple>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <bit>

libcxx/include/unordered_set

 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
+#include <__memory/allocator.h>
 #include <__node_handle>
+#include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #endif
 

libcxx/include/vector

 #include <__functional/unary_function.h>
 #include <__iterator/advance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
+#include <__memory/temp_value.h>
+#include <__memory/uninitialized_algorithms.h>
 #include <__split_buffer>
+#include <__type_traits/is_allocator.h>
+#include <__type_traits/noexcept_move_assign_container.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <climits>
 #include <cstdlib>
 #include <cstring>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>
-#include <memory>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <typeinfo>
 #  include <utility>

libcxx/test/libcxx/memory/compressed_pair/compressed_pair.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <assert.h>
 #include <memory>
+#include <new>
 
 #include "test_macros.h"
 
 typedef std::__compressed_pair<int, unsigned> IntPair;
 
 void test_constructor() {
   IntPair value;
   assert(value.first() == 0);

libcxx/test/libcxx/private_headers.verify.cpp

 #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_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/voidify.h> // expected-error@*:* {{use of private header from outside its module: '__memory/voidify.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 <__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/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'}}

libcxx/test/libcxx/transitive_includes/cxx2b/expected.algorithm

-atomic
 bit
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
-ratio
-stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.any

 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.barrier

 atomic
 climits
 cmath
 compare
-concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
-initializer_list
 iosfwd
 limits
-memory
 new
 ratio
-stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.bitset

-atomic
 cctype
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
-ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
-ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.ccomplex

 cwctype
 exception
 initializer_list
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 sstream
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.codecvt

 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 mutex
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.complex

 cwctype
 exception
 initializer_list
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 sstream
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.condition_variable

 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.ctgmath

 cwctype
 exception
 initializer_list
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 sstream
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.deque

 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_algorithm

 algorithm
-atomic
 bit
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
-ratio
-stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_coroutine

-atomic
-climits
-cmath
-compare
-concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
-initializer_list
-iosfwd
 limits
-memory
 new
-ratio
-stdexcept
-tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_deque

 ctime
 deque
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_forward_list

 ctime
 exception
 experimental/memory_resource
 experimental/utility
 forward_list
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_functional

 array
 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 functional
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 unordered_map
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_list

 ctime
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
 list
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_map

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
 map
-memory
 new
 optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_memory_resource

-atomic
-climits
 cmath
 compare
-concepts
 cstddef
 cstdint
 cstdlib
-cstring
-ctime
 exception
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 new
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_regex

 deque
 exception
 experimental/memory_resource
 experimental/string
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 mutex
 new
 ratio
 regex
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 utility
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_set

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
-ratio
 set
 stdexcept
 tuple
 type_traits
-typeinfo
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_string

-atomic
 cctype
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
-ctime
 cwchar
 cwctype
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 new
-ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
-typeinfo
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_unordered_map

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 unordered_map
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_unordered_set

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 unordered_set
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_vector

 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/memory_resource
 experimental/utility
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 utility
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.ext_hash_map

 ctime
 cwchar
 cwctype
 exception
 functional
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
 unordered_map
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.ext_hash_set

 ctime
 cwchar
 cwctype
 exception
 functional
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
 unordered_map
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.filesystem

 exception
 initializer_list
 iomanip
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.format

 cwchar
 cwctype
 exception
 initializer_list
 ios
 iosfwd
 limits
 locale
-memory
 mutex
 new
 optional
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.forward_list

 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.fstream

 filesystem
 initializer_list
 iomanip
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.functional

 array
 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 unordered_map
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.future

 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 mutex
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 thread
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.iomanip

 cwctype
 exception
 initializer_list
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.ios

 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 mutex
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.iostream

 cwctype
 exception
 initializer_list
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.istream

 cwchar
 cwctype
 exception
 initializer_list
 ios
 iosfwd
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.list

 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.locale

 ctime
 cwchar
 cwctype
 exception
 initializer_list
 ios
 iosfwd
 limits
-memory
 mutex
 new
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.map

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.mutex

 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.ostream

 cwchar
 cwctype
 exception
 initializer_list
 ios
 iosfwd
 limits
 locale
-memory
 mutex
 new
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.queue

-array
 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 deque
 exception
-functional
 initializer_list
 iosfwd
 limits
-memory
 new
-optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
-unordered_map
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.random

 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 numeric
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.regex

 ctime
 cwchar
 cwctype
 deque
 exception
 initializer_list
 iosfwd
 limits
-memory
 mutex
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.scoped_allocator

-atomic
-climits
 cmath
 compare
-concepts
 cstddef
 cstdint
 cstdlib
-cstring
-ctime
 exception
-initializer_list
-iosfwd
 limits
-memory
 new
-ratio
-stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.set

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.shared_mutex

-atomic
 cctype
 cerrno
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.sstream

 cwctype
 exception
 initializer_list
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.stack

 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 deque
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.streambuf

 ctime
 cwchar
 cwctype
 exception
 initializer_list
 ios
 iosfwd
 limits
-memory
 mutex
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.string

-atomic
 cctype
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
-ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
-ratio
 stdexcept
 string_view
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.strstream

 cwctype
 exception
 initializer_list
 ios
 iosfwd
 istream
 limits
 locale
-memory
 mutex
 new
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.system_error

-atomic
 cctype
 cerrno
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
-ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
-ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.thread

-atomic
 cctype
 cerrno
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.unordered_map

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.unordered_set

-atomic
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.vector

 atomic
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 initializer_list
 iosfwd
 limits
-memory
 new
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 version

libcxx/test/libcxx/utilities/any/allocator.pass.cpp

 // Check that we're consistently using std::allocator_traits to
 // allocate/deallocate/construct/destroy objects in std::any.
 // See https://llvm.org/PR45099 for details.
 
 #include <any>
 #include <cassert>
 #include <cstddef>
 #include <memory>
+#include <new>
 #include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 
 // Make sure we don't fit in std::any's SBO
 struct Large { char big[sizeof(std::any) + 1]; };

libcxx/test/libcxx/utilities/memory/pointer.conversion/to_address.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class T> constexpr T* __to_address(T* p) noexcept;
 // template <class Ptr> constexpr auto __to_address(const Ptr& p) noexcept;
 
 #include <memory>
 #include <cassert>
+#include <utility>
+
 #include "test_macros.h"
 
 struct Irrelevant;
 
 struct P1 {
     using element_type = Irrelevant;
     TEST_CONSTEXPR explicit P1(int *p) : p_(p) { }
     TEST_CONSTEXPR int *operator->() const { return p_; }

libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 #include <memory>
+#include <type_traits>
 
 template <int> struct Tag {};
 
 template <int ID>
 using SPtr = std::shared_ptr<void(Tag<ID>)>;
 
 template <int ID>
 using FnType = void(Tag<ID>);

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // template<LessThanComparable T>
 //   pair<const T&, const T&>
 //   minmax(const T& a, const T& b);
 
 #include <algorithm>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 template <class T>
 void
 test(const T& a, const T& b, const T& x, const T& y)
 {
     std::pair<const T&, const T&> p = std::minmax(a, b);

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp

 // <algorithm>
 
 // template<class T>
 //   pair<T, T>
 //   minmax(initializer_list<T> t);
 
 #include <algorithm>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     assert((std::minmax({1, 2, 3}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({1, 3, 2}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({2, 1, 3}) == std::pair<int, int>(1, 3)));

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax.pass.cpp

 //   requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
 //   constexpr ranges::minmax_result<range_value_t<R>>
 //     ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
 
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
+#include <memory>
 #include <ranges>
 
 #include "test_iterators.h"
 
 template <class T>
 concept HasMinMax = requires { std::ranges::minmax(std::declval<T>()); };
 
 struct NoLessThanOp {};

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp

 
 #include <algorithm>
 #include <iterator>
 #include <numeric>
 #include <random>
 #include <cassert>
 #include <vector>
 #include <deque>
+#include <utility>
 
 #include "test_macros.h"
 
 std::mt19937 randomness;
 
 template <class Container, class RI>
 void
 test_sort_helper(RI f, RI l)

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 // <forward_list>
 
 // void push_front(const value_type& x);
 
 #include <forward_list>
 #include <cassert>
+#include <exception>
 
 #include "test_macros.h"
 
 // Flag that makes the copy constructor for CMyClass throw an exception
 static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {

libcxx/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 // <list>
 
 // void push_back(const value_type& x);
 
 #include <list>
 #include <cassert>
+#include <exception>
 
 #include "test_macros.h"
 
 // Flag that makes the copy constructor for CMyClass throw an exception
 static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {

libcxx/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 // <list>
 
 // void push_front(const value_type& x);
 
 #include <list>
 #include <cassert>
+#include <exception>
 
 #include "test_macros.h"
 
 // Flag that makes the copy constructor for CMyClass throw an exception
 static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {

libcxx/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
 #include <experimental/coroutine>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 namespace coro = std::experimental;
 
 using SuspendT = std::experimental::coroutines_v1::suspend_always;
 
 constexpr bool check_suspend_constexpr() {

libcxx/test/std/experimental/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
 #include <experimental/coroutine>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 namespace coro = std::experimental;
 
 using SuspendT = std::experimental::coroutines_v1::suspend_never;
 
 constexpr bool check_suspend_constexpr() {

libcxx/test/std/localization/locales/locale.global.templates/use_facet.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <class Facet> const Facet& use_facet(const locale& loc);
 
 #include <locale>
 #include <cassert>
+#include <typeinfo>
 
 #include "test_macros.h"
 
 int facet_count = 0;
 
 struct my_facet
     : public std::locale::facet
 {

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

 // Some basic examples of how zip_view might be used in the wild. This is a general
 // collection of sample algorithms and functions that try to mock general usage of
 // this view.
 
 #include <ranges>
 
 #include <array>
 #include <cassert>
+#include <tuple>
 #include <vector>
 #include <string>
 
 int main(int, char**) {
   {
     std::ranges::zip_view v{
         std::array{1, 2},
         std::vector{4, 5, 6},

libcxx/test/std/strings/basic.string/string.capacity/max_size.pass.cpp

 // 1. If allocator_may_return_null=0 then they will fail because the allocation
 //    returns null.
 // 2. If allocator_may_return_null=1 then they will fail because the allocation
 //    is too large to succeed.
 // UNSUPPORTED: sanitizer-new-delete
 
 #include <string>
 #include <cassert>
+#include <new>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test1(const S& s)
 {

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.verify.cpp

 // class function<R(ArgTypes...)>
 
 // template<class F, class A> function(allocator_arg_t, const A&, F);
 //
 // This signature was removed in C++17
 
 #include <functional>
 #include <cassert>
+#include <memory>
 
 #include "test_macros.h"
 
 void foo(int) {}
 
 int main(int, char**)
 {
     std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo); // expected-error {{no matching constructor for initialization of}}
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.verify.cpp

 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, const function&);
 //
 // This signature was removed in C++17
 
 #include <functional>
 #include <cassert>
+#include <memory>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::function<void(int)> F;
     F f1;
     F f2(std::allocator_arg, std::allocator<int>(), f1); // expected-error {{no matching constructor for initialization of}}
     return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp

 //     static constexpr void construct(allocator_type& a, Ptr p, Args&&... args);
 //     ...
 // };
 
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
 template <class T>
 struct A
 {
     typedef T value_type;

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 // <memory>
 
 // allocator:
 // constexpr T* allocate(size_t n);
 
 #include <memory>
 #include <cassert>
+#include <new>
 
 #include "test_macros.h"
 
 template <typename T>
 void test_max(size_t count)
 {
     std::allocator<T> a;
     try {

libcxx/test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 #include <memory>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 // <memory>
 //
 // template <class Alloc>
 // struct allocator_traits
 // {

libcxx/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp

 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T> constexpr T* to_address(T* p) noexcept;
 // template <class Ptr> constexpr auto to_address(const Ptr& p) noexcept;
 
 #include <memory>
 #include <cassert>
+#include <utility>
+
 #include "test_macros.h"
 
 struct Irrelevant;
 
 struct P1 {
     using element_type = Irrelevant;
     constexpr explicit P1(int *p) : p_(p) { }
     constexpr int *operator->() const { return p_; }

libcxx/test/std/utilities/memory/pointer.traits/pointer.traits.functions/pointer_to.pass.cpp

 // struct pointer_traits
 // {
 //     static pointer pointer_to(<details>);
 //     ...
 // };
 
 #include <memory>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 template <class T>
 struct A
 {
 private:
     struct nat {};

libcxx/test/std/utilities/memory/pointer.traits/pointer_to.pass.cpp

 // struct pointer_traits<T*>
 // {
 //     static pointer pointer_to(<details>); // constexpr in C++20
 //     ...
 // };
 
 #include <memory>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test()
 {
     {
         int i = 0;
         static_assert(std::is_same<decltype(std::pointer_traits<int*>::pointer_to(i)), int*>::value, "");

libcxx/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp

 //   get_temporary_buffer(ptrdiff_t n);
 //
 // template <class T>
 //   void
 //   return_temporary_buffer(T* p);
 
 #include <memory>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct alignas(32) A {
     int field;
 };
 
 int main(int, char**)
 {
     std::pair<A*, std::ptrdiff_t> ip = std::get_temporary_buffer<A>(5);
     assert(!(ip.first == nullptr) ^ (ip.second == 0));
     assert(reinterpret_cast<uintptr_t>(ip.first) % alignof(A) == 0);
     std::return_temporary_buffer(ip.first);
 
   return 0;
 }

libcxx/test/std/utilities/memory/temporary.buffer/temporary_buffer.pass.cpp

 //   get_temporary_buffer(ptrdiff_t n);
 //
 // template <class T>
 //   void
 //   return_temporary_buffer(T* p);
 
 #include <memory>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::pair<int*, std::ptrdiff_t> ip = std::get_temporary_buffer<int>(5);
     assert(ip.first);
     assert(ip.second == 5);
     std::return_temporary_buffer(ip.first);
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr_rv.pass.cpp

 
 // shared_ptr
 
 // shared_ptr& operator=(shared_ptr&& r);
 
 #include <memory>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
     B() {++count;}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp

 
 // shared_ptr
 
 // template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
 
 #include <memory>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
     B() {++count;}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/deduction.pass.cpp

 
 // template<class T> class shared_ptr
 
 // shared_ptr(weak_ptr<T>) -> shared_ptr<T>
 // shared_ptr(unique_ptr<T>) -> shared_ptr<T>
 
 #include <memory>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct A {};
 
 struct D {
   void operator()(A const* ptr) const
   {

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_copy_move.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
 // template<class Y> shared_ptr(const shared_ptr<Y>& r);
 
 #include <memory>
 #include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 
 struct A {
   int x = 42;
 };
 
 struct ADel : std::default_delete<A> {

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
 // template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p);
 
 #include <memory>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
     B() {++count;}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_rv.pass.cpp

 // <memory>
 
 // shared_ptr
 
 // shared_ptr(shared_ptr&& r);
 
 #include <memory>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct A
 {
     static int count;
 
     A() {++count;}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp

 // <memory>
 
 // template <class Y, class D> shared_ptr(unique_ptr<Y, D>&&r);
 
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 struct B
 {
     static int count;
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_construct.pass.cpp

 // template<class T, class A, class... Args>
 // shared_ptr<T> allocate_shared(const A& a, Args&&... args);
 
 // This test checks that allocator_traits::construct is used in allocate_shared
 // as requested in C++20 (via P0674R1).
 
 #include "test_macros.h"
 
-#include <memory>
 #include <cassert>
+#include <memory>
+#include <new>
+#include <utility>
 
 static bool construct_called = false;
 static bool destroy_called = false;
 static unsigned allocator_id = 0;
 
 template <class T>
 struct MyAllocator {
 public:

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/weak_ptr.pass.cpp

 
 // weak_ptr
 
 // weak_ptr& operator=(const weak_ptr& r);
 
 #include <memory>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
     B() {++count;}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr.pass.cpp

 // weak_ptr
 
 // weak_ptr(const weak_ptr& r);
 // weak_ptr(weak_ptr &&r)
 
 #include <memory>
 #include <type_traits>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
     B() {++count;}

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.weakptr/bad_weak_ptr.pass.cpp

 
 // class bad_weak_ptr
 //     : public std::exception
 // {
 // public:
 //     bad_weak_ptr();
 // };
 
+#include <exception>
 #include <memory>
 #include <type_traits>
 #include <cassert>
 #include <cstring>
 
 #include "test_macros.h"
 
 int main(int, char**)

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get_deleter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // unique_ptr
 
 // test get_deleter()
 
 #include <memory>
 #include <cassert>
+#include <type_traits>
+
 #include "test_macros.h"
 
 struct Deleter {
   Deleter() {}
 
   void operator()(void*) const {}
 
   int test() { return 5; }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp

 
 // tuple(tuple&& u);
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <utility>
 #include <cassert>
+#include <memory>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 
 struct ConstructsWithTupleLeaf
 {
     ConstructsWithTupleLeaf() {}
 

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
 #include <tuple>
 #include <string>
+#include <memory>
+
 #include "test_macros.h"
 
 struct UserType {};
 
 void test_bad_index() {
     std::tuple<long, long, char, std::string, char, UserType, char> t1;
     TEST_IGNORE_NODISCARD std::get<int>(t1); // expected-error@tuple:* {{type not found}}
     TEST_IGNORE_NODISCARD std::get<long>(t1); // expected-note {{requested here}}

libcxx/test/support/allocators.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ALLOCATORS_H
 #define ALLOCATORS_H
 
 #include <memory>
+#include <new>
 #include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER >= 11
 
 template <class T>

libcxx/test/support/container_test_types.h

  * // Assert that the "expect" was consumed by a matching "check" call within
  * // Alloc.
  * assert(!cc->unexpected());
  *
  */
 
 #include <functional>
 #include <cassert>
+#include <new>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER < 11
 #error This header requires C++11 or greater
 #endif
 
 namespace detail {

libcxx/test/support/controlled_allocators.h

 
 #include <memory>
 #include <type_traits>
 #include <cstddef>
 #include <cstdlib>
 #include <cstring>
 #include <cstdint>
 #include <cassert>
+#include <new>
+
 #include "test_macros.h"
 #include "type_id.h"
 
 #if TEST_STD_VER < 11
 #error This header requires C++11 or greater
 #endif
 
 struct AllocController;

libcxx/test/support/min_allocator.h

 
 #include <cstddef>
 #include <cstdlib>
 #include <cstddef>
 #include <cassert>
 #include <climits>
 #include <iterator>
 #include <memory>
+#include <new>
 
 #include "test_macros.h"
 
 template <class T>
 class bare_allocator
 {
 public:
     typedef T value_type;