[libc++][Modules] Add missing __fwd includes

[iana]

Summary

A few __fwd includes are missing from public modules that will become noticeable when the private submodules are split into their own top level modules (D144322). Add the missing includes.

[iana]

Reordering in the stack

[iana]

Rebase

[iana]

Rebase

[iana]

Rebase

[iana]

Rebase

[iana]

Rebase

[iana]

Rebase

[iana]

Rebase

[iana]

Rebase

[iana]

Update transitive includes

[iana]

Don't include the textual headers in algorithm

[iana]

Rebase

[iana]

Update the headers

[iana]

Rebase

[iana]

Remove a redundant include

[iana]

Restore an accidentally deleted comment

[iana]

Rebase

[iana]

Rebase

[iana]

Rebase

[iana]

@Mordante @ldionne do either of you understand the CI failure? I can't make heads or tails of it...

[EricWF]

@ldionne @philnik

The complexity of having hundreds of headers is starting to show its head.
How do we prevent this class of bugs from continuing to occur?

libcxx/include/algorithm

1746

Thanks for fixing this.

The comment below isn't about your change in particular, but rather the general structure libc++ has invented for itself recently.

I'm concerned because these are potentially fairly serious bugs, and they would never had occurred had the things in algorithm been in algorithm.
This furthers my concern that we've invented a bunch of complexity which only debatably pulls its weight.

I'll have to improve my understanding of the modules internals, because I'm certain we can find some ways to simplify this.

[EricWF]

Removing the LGTM until the bots build.
This looks to be taking a lot of effort to make work?

[iana]

In D153216#4462380, @EricWF wrote:

Removing the LGTM until the bots build.
This looks to be taking a lot of effort to make work?

Yes it's really taken quite a lot of effort to get it to work.

[iana]

libcxx/include/algorithm

1746

We could probably write a unit test to verify that the public headers include all of the private headers. We already have the list in private_headers in header_information.py. We'd just have to map the __fwd headers to their public header.

[iana]

In D153216#4462376, @EricWF wrote:

The complexity of having hundreds of headers is starting to show its head.

Lol wait until you see the module map generator script in D144322. Maybe we did go overboard with nearly 1000 headers, but the private detail headers are necessary to prevent include and module cycles between the public headers.

[philnik]

I don't think we actually want all of these headers to be included in the top-level header. Looking at the changes, all of these are implementation-detail headers, which don't contain any public API, so there is no need for them to be included.

[iana]

Rebase

[iana]

In D153216#4464361, @philnik wrote:

I don't think we actually want all of these headers to be included in the top-level header. Looking at the changes, all of these are implementation-detail headers, which don't contain any public API, so there is no need for them to be included.

I think we do need them though. Previously importing e.g. std.type_traits would give you all of the detail headers. Once those are put in their own top level modules, they only get included if the public header includes them.

[philnik]

In D153216#4465367, @iana wrote:

In D153216#4464361, @philnik wrote:

I don't think we actually want all of these headers to be included in the top-level header. Looking at the changes, all of these are implementation-detail headers, which don't contain any public API, so there is no need for them to be included.

I think we do need them though. Previously importing e.g. std.type_traits would give you all of the detail headers. Once those are put in their own top level modules, they only get included if the public header includes them.

I don't see the problem. Users shouldn't ever refer to the stuff defined in these headers. If they do and splitting up the module breaks them, that's their problem, not ours.

[iana]

In D153216#4465444, @philnik wrote:

In D153216#4465367, @iana wrote:

In D153216#4464361, @philnik wrote:

I don't think we actually want all of these headers to be included in the top-level header. Looking at the changes, all of these are implementation-detail headers, which don't contain any public API, so there is no need for them to be included.

I think we do need them though. Previously importing e.g. std.type_traits would give you all of the detail headers. Once those are put in their own top level modules, they only get included if the public header includes them.

I don't see the problem. Users shouldn't ever refer to the stuff defined in these headers. If they do and splitting up the module breaks them, that's their problem, not ours.

Alright, let me try without this one. I still worry about the behavior change, but maybe it won't be noticeable since most of these submodules don't export anything. And it would let me sidestep the bizarre problem this causes in CI...

[iana]

In D153216#4465685, @iana wrote:

In D153216#4465444, @philnik wrote:

In D153216#4465367, @iana wrote:

In D153216#4464361, @philnik wrote:

I don't think we actually want all of these headers to be included in the top-level header. Looking at the changes, all of these are implementation-detail headers, which don't contain any public API, so there is no need for them to be included.

I think we do need them though. Previously importing e.g. std.type_traits would give you all of the detail headers. Once those are put in their own top level modules, they only get included if the public header includes them.

I don't see the problem. Users shouldn't ever refer to the stuff defined in these headers. If they do and splitting up the module breaks them, that's their problem, not ours.

Alright, let me try without this one. I still worry about the behavior change, but maybe it won't be noticeable since most of these submodules don't export anything. And it would let me sidestep the bizarre problem this causes in CI...

Not doing this adds loads of failures to D144322, but let me try to add more exports to fix them.

[Mordante]

In D153216#4461976, @iana wrote:

@Mordante @ldionne do either of you understand the CI failure? I can't make heads or tails of it...

Do you have a link to this failed build? The latest failure is just a #include <__memory/uninitialized_buffer.h>, I assume you don't need help with that.

In D153216#4462376, @EricWF wrote:

@ldionne @philnik

The complexity of having hundreds of headers is starting to show its head.
How do we prevent this class of bugs from continuing to occur?

I'm still not sure why this issue doesn't show up in the modular builds we test in the CI.

[iana]

In D153216#4466234, @Mordante wrote:

In D153216#4461976, @iana wrote:

@Mordante @ldionne do either of you understand the CI failure? I can't make heads or tails of it...

Do you have a link to this failed build? The latest failure is just a #include <__memory/uninitialized_buffer.h>, I assume you don't need help with that.

It’s this one https://buildkite.com/llvm-project/libcxx-ci/builds/27284#018908b1-cc51-4a8b-af88-8bd36ded537b there’s a c++ module error that I can’t figure out

[Mordante]

In D153216#4466307, @iana wrote:

In D153216#4466234, @Mordante wrote:

In D153216#4461976, @iana wrote:

@Mordante @ldionne do either of you understand the CI failure? I can't make heads or tails of it...

Do you have a link to this failed build? The latest failure is just a #include <__memory/uninitialized_buffer.h>, I assume you don't need help with that.

It’s this one https://buildkite.com/llvm-project/libcxx-ci/builds/27284#018908b1-cc51-4a8b-af88-8bd36ded537b there’s a c++ module error that I can’t figure out

Thanks! The issue is that you added a new named declaration to <type_traits> and didn't export it from the std module. When they are no longer in sync this test fails.

However I'm not convinced the added named declaration is_execution_policy should be part of <type_traits>. Let's see what @philnik has to say.

libcxx/include/type_traits

473

@philnik is_execution_policy is part of <execution>. I don't find the reason why this has been added to the __type_traits directory. Is that a bug?

[philnik]

libcxx/include/type_traits

473

That's a good question. I probably just put it there because it feels like a type trait, and I didn't think about where it should actually live. It should probably be moved to __execution/.

[iana]

Add the missing using to the type_traits module

[iana]

Remove a removed header

[iana]

Fix a typo

[iana]

Rebase

[ldionne]

In D153216#4462376, @EricWF wrote:

@ldionne @philnik

The complexity of having hundreds of headers is starting to show its head.
How do we prevent this class of bugs from continuing to occur?

I think you're misunderstanding what's happening. If it weren't for the header splitting we've been doing for the past 1-2 years, this whole effort would have been dead in the water since headers had cyclic dependencies. Breaking those cyclic dependencies between top-level headers is one of the reason for splitting the headers in the first place, and it would have been a pre-requisite for this work to happen.

Re this review, I think most of the includes are not desired. I would suggest turning this into a small "add missing includes" patch with only the few includes that were truly missing.

libcxx/include/algorithm

1738

All of these seem to be unwanted.

libcxx/include/array

121

This one's good, the definition should include its forward declaration if there's one, I guess.

libcxx/include/chrono

767–768

No.

libcxx/include/format

195

I think all of those are no.

libcxx/include/functional

533

All those are internal utilities as well, so not needed!

libcxx/include/iterator

678

Same, not needed.

libcxx/include/memory

876

Same, not needed.

libcxx/include/memory_resource

53

Yes!

libcxx/include/ranges

342

All of those are internal, not needed.

libcxx/include/stop_token

28

Same, not needed.

libcxx/include/string

554

Same, not needed.

libcxx/include/thread

85

Same, not needed.

libcxx/include/tuple

210

Yes!

214

I don't think we want this one.

214

This one is no also, we use __tuple_like_ext here but not __tuple_like.

libcxx/include/type_traits

429

I think all of those are unwanted.

libcxx/include/utility

244

None of them seem needed.

libcxx/modules/std/type_traits.cppm

228

Can you explain why that's needed? This doesn't belong to <type_traits>, it belongs to <execution>.

[philnik]

libcxx/include/memory_resource

53

IMO __memory_resource/memory_resource.h should include the forward declaration, not the top-level header.

[ldionne]

libcxx/include/memory_resource

53

Ah, you're right, I actually mis-read the name of the header this was added in. Yup, this one should go away then.

[iana]

libcxx/modules/std/type_traits.cppm

228

It was needed if <type_traits> included <__type_traits/is_execution_policy.h>, but now that that's gone this can go too.

[iana]

Update for review feedback

[philnik]

Thanks for the cleanup. LGTM. Let's wait a day or two before landing in case @Mordante or @ldionne have any more comments.

[iana]

Rebase

libcxx/include/algorithm

template <class BidirectionalIterator>
     prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
 
 template <class BidirectionalIterator, class Compare>
     constexpr bool     // constexpr in C++20
     prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cstddef>
 #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/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/copy.h>
 #include <__algorithm/copy_backward.h>
 #include <__algorithm/copy_if.h>
+#include <__algorithm/copy_move_common.h>
 #include <__algorithm/copy_n.h>
 #include <__algorithm/count.h>
 #include <__algorithm/count_if.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/equal_range.h>
 #include <__algorithm/fill.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/find.h>
 #include <__algorithm/find_end.h>
 #include <__algorithm/find_first_of.h>
 #include <__algorithm/find_if.h>
 #include <__algorithm/find_if_not.h>
 #include <__algorithm/for_each.h>
 #include <__algorithm/for_each_n.h>
+#include <__algorithm/for_each_segment.h>
 #include <__algorithm/generate.h>
 #include <__algorithm/generate_n.h>
 #include <__algorithm/half_positive.h>
 #include <__algorithm/in_found_result.h>
 #include <__algorithm/in_fun_result.h>
 #include <__algorithm/in_in_out_result.h>
 #include <__algorithm/in_in_result.h>
 #include <__algorithm/in_out_out_result.h>
 #include <__algorithm/in_out_result.h>
 #include <__algorithm/includes.h>
 #include <__algorithm/inplace_merge.h>
 #include <__algorithm/is_heap.h>
 #include <__algorithm/is_heap_until.h>
 #include <__algorithm/is_partitioned.h>
 #include <__algorithm/is_permutation.h>
 #include <__algorithm/is_sorted.h>
 #include <__algorithm/is_sorted_until.h>
 #include <__algorithm/iter_swap.h>
+#include <__algorithm/iterator_operations.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/make_heap.h>
+#include <__algorithm/make_projected.h>
 #include <__algorithm/max.h>
 #include <__algorithm/max_element.h>
 #include <__algorithm/merge.h>
 #include <__algorithm/min.h>
 #include <__algorithm/min_element.h>
 #include <__algorithm/min_max_result.h>
 #include <__algorithm/minmax.h>
 #include <__algorithm/minmax_element.h>
 #include <__algorithm/mismatch.h>
 #include <__algorithm/move.h>
 #include <__algorithm/move_backward.h>
 #include <__algorithm/next_permutation.h>
 #include <__algorithm/none_of.h>
 #include <__algorithm/nth_element.h>
 #include <__algorithm/partial_sort.h>
 #include <__algorithm/partial_sort_copy.h>
 #include <__algorithm/partition.h>
 #include <__algorithm/partition_copy.h>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
 #include <__algorithm/pstl_any_all_none_of.h>
+#include <__algorithm/pstl_backend.h>
+#include <__algorithm/pstl_backends/cpu_backend.h>
+#include <__algorithm/pstl_backends/cpu_backends/any_of.h>
+#include <__algorithm/pstl_backends/cpu_backends/backend.h>
+#include <__algorithm/pstl_backends/cpu_backends/fill.h>
+#include <__algorithm/pstl_backends/cpu_backends/find_if.h>
+#include <__algorithm/pstl_backends/cpu_backends/for_each.h>
+#include <__algorithm/pstl_backends/cpu_backends/merge.h>
+#include <__algorithm/pstl_backends/cpu_backends/stable_sort.h>
+#include <__algorithm/pstl_backends/cpu_backends/transform.h>
+#include <__algorithm/pstl_backends/cpu_backends/transform_reduce.h>
 #include <__algorithm/pstl_copy.h>
 #include <__algorithm/pstl_count.h>
 #include <__algorithm/pstl_fill.h>
 #include <__algorithm/pstl_find.h>
 #include <__algorithm/pstl_for_each.h>
+#include <__algorithm/pstl_frontend_dispatch.h>
 #include <__algorithm/pstl_generate.h>
 #include <__algorithm/pstl_is_partitioned.h>
 #include <__algorithm/pstl_merge.h>
 #include <__algorithm/pstl_replace.h>
 #include <__algorithm/pstl_stable_sort.h>
 #include <__algorithm/pstl_transform.h>
 #include <__algorithm/push_heap.h>
 #include <__algorithm/ranges_adjacent_find.h>

 #include <__algorithm/ranges_includes.h>
 #include <__algorithm/ranges_inplace_merge.h>
 #include <__algorithm/ranges_is_heap.h>
 #include <__algorithm/ranges_is_heap_until.h>
 #include <__algorithm/ranges_is_partitioned.h>
 #include <__algorithm/ranges_is_permutation.h>
 #include <__algorithm/ranges_is_sorted.h>
 #include <__algorithm/ranges_is_sorted_until.h>
+#include <__algorithm/ranges_iterator_concept.h>
 #include <__algorithm/ranges_lexicographical_compare.h>
 #include <__algorithm/ranges_lower_bound.h>
 #include <__algorithm/ranges_make_heap.h>
 #include <__algorithm/ranges_max.h>
 #include <__algorithm/ranges_max_element.h>
 #include <__algorithm/ranges_merge.h>
 #include <__algorithm/ranges_min.h>
 #include <__algorithm/ranges_min_element.h>

 #include <__algorithm/shift_right.h>
 #include <__algorithm/shuffle.h>
 #include <__algorithm/sift_down.h>
 #include <__algorithm/sort.h>
 #include <__algorithm/sort_heap.h>
 #include <__algorithm/stable_partition.h>
 #include <__algorithm/stable_sort.h>
 #include <__algorithm/swap_ranges.h>
+#include <__algorithm/three_way_comp_ref_type.h>
 #include <__algorithm/transform.h>
+#include <__algorithm/uniform_random_bit_generator_adaptor.h>
 #include <__algorithm/unique.h>
 #include <__algorithm/unique_copy.h>
 #include <__algorithm/unwrap_iter.h>
+#include <__algorithm/unwrap_range.h>
 #include <__algorithm/upper_bound.h>
 
 // standard-mandated includes
 
 // [algorithm.syn]
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/array

 
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/swap_ranges.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__fwd/array.h>
 #include <__iterator/reverse_iterator.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_const.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_move_constructible.h>
 #include <__type_traits/is_nothrow_constructible.h>

libcxx/include/chrono

 constexpr chrono::year                                  operator ""y(unsigned long long y) noexcept; // C++20
 }  // chrono_literals
 }  // literals
 
 }  // std
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__chrono/calendar.h>
+#include <__chrono/concepts.h>
 #include <__chrono/convert_to_timespec.h>
 #include <__chrono/convert_to_tm.h>
 #include <__chrono/day.h>
 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
 #include <__chrono/hh_mm_ss.h>
 #include <__chrono/high_resolution_clock.h>
 #include <__chrono/literals.h>

libcxx/include/format

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__format/buffer.h>
 #include <__format/concepts.h>
 #include <__format/container_adaptor.h>
 #include <__format/enable_insertable.h>
+#include <__format/escaped_output_table.h>
+#include <__format/extended_grapheme_cluster_table.h>
 #include <__format/format_arg.h>
 #include <__format/format_arg_store.h>
 #include <__format/format_args.h>
 #include <__format/format_context.h>
 #include <__format/format_error.h>
 #include <__format/format_functions.h>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
 #include <__format/format_string.h>
 #include <__format/format_to_n_result.h>
 #include <__format/formatter.h>
 #include <__format/formatter_bool.h>
 #include <__format/formatter_char.h>
 #include <__format/formatter_floating_point.h>
 #include <__format/formatter_integer.h>
+#include <__format/formatter_integral.h>
+#include <__format/formatter_output.h>
 #include <__format/formatter_pointer.h>
 #include <__format/formatter_string.h>
 #include <__format/formatter_tuple.h>
 #include <__format/parser_std_format_spec.h>
 #include <__format/range_default_formatter.h>
 #include <__format/range_formatter.h>
 #include <__format/unicode.h>
+#include <__format/width_estimation_table.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FORMAT

libcxx/include/functional

 #include <__functional/binder2nd.h>
 #include <__functional/boyer_moore_searcher.h>
 #include <__functional/compose.h>
 #include <__functional/default_searcher.h>
 #include <__functional/function.h>
 #include <__functional/hash.h>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
+#include <__functional/is_transparent.h>
 #include <__functional/mem_fn.h> // TODO: deprecate
 #include <__functional/mem_fun_ref.h>
 #include <__functional/not_fn.h>
 #include <__functional/operations.h>
+#include <__functional/perfect_forward.h>
 #include <__functional/pointer_to_binary_function.h>
 #include <__functional/pointer_to_unary_function.h>
 #include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
 #include <__functional/unary_negate.h>
+#include <__functional/weak_result_type.h>
+#include <__fwd/hash.h>
 #include <__type_traits/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <memory> // TODO: find out why removing this breaks the modules build
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/iterator

 template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;           // C++17
 template <class E> constexpr const E* data(initializer_list<E> il) noexcept;      // C++17
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/access.h>
 #include <__iterator/advance.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/bounded_iter.h>
 #include <__iterator/common_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/counted_iterator.h>
+#include <__iterator/cpp17_iterator_concepts.h>
 #include <__iterator/data.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/distance.h>
 #include <__iterator/empty.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/front_insert_iterator.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__iterator/insert_iterator.h>
 #include <__iterator/istream_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/iterator_with_data.h>
 #include <__iterator/mergeable.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/move_sentinel.h>
 #include <__iterator/next.h>
 #include <__iterator/ostream_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
 #include <__iterator/permutable.h>
 #include <__iterator/prev.h>
 #include <__iterator/projected.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_access.h>
 #include <__iterator/reverse_iterator.h>
+#include <__iterator/segmented_iterator.h>
 #include <__iterator/size.h>
 #include <__iterator/sortable.h>
 #include <__iterator/unreachable_sentinel.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <cstddef>
 #include <initializer_list>

libcxx/include/memory

template <class T, class Alloc>
   inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 
 // [ptr.align]
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 template<size_t N, class T>
 [[nodiscard]] constexpr T* assume_aligned(T* ptr); // since C++20
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/align.h>
+#include <__memory/aligned_alloc.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_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/assume_aligned.h>
 #include <__memory/auto_ptr.h>
+#include <__memory/builtin_new_allocator.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>
+#include <__memory/destruct_n.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/swap_allocator.h>
+#include <__memory/temp_value.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
 #include <__memory/uses_allocator_construction.h>
+#include <__memory/voidify.h>
 #include <version>
 
 // standard-mandated includes
 
 // [memory.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/memory_resource

namespace std::pmr {
   class unsynchronized_pool_resource;
   class monotonic_buffer_resource;
 
 } // namespace std::pmr
 
  */
 
 #include <__config>
+#include <__fwd/memory_resource.h>
 #include <__memory_resource/memory_resource.h>
 #include <__memory_resource/monotonic_buffer_resource.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__memory_resource/pool_options.h>
 #include <__memory_resource/synchronized_pool_resource.h>
 #include <__memory_resource/unsynchronized_pool_resource.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif /* _LIBCPP_MEMORY_RESOURCE */

libcxx/include/ranges

namespace std {
   struct tuple_element<0, const ranges::subrange<I, S, K>> {
     using type = I;
   };
 
   template<class I, class S, ranges::subrange_kind K>
   struct tuple_element<1, const ranges::subrange<I, S, K>> {
     using type = S;
   };
 
   struct from_range_t { explicit from_range_t() = default; };  // Since C++23
   inline constexpr from_range_t from_range{};                  // Since C++23
 }
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__fwd/subrange.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/as_rvalue_view.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
 #include <__ranges/counted.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/drop_while_view.h>
 #include <__ranges/elements_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/filter_view.h>
 #include <__ranges/from_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/lazy_split_view.h>
+#include <__ranges/movable_box.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/owning_view.h>
+#include <__ranges/range_adaptor.h>
 #include <__ranges/rbegin.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/rend.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/split_view.h>
 #include <__ranges/subrange.h>

libcxx/include/stop_token

namespace std {
   class stop_source;
 
   // no-shared-stop-state indicator
   struct nostopstate_t {
     explicit nostopstate_t() = default;
   };
   inline constexpr nostopstate_t nostopstate{};
 
   // [stopcallback], class template stop_callback
   template<class Callback>
     class stop_callback;
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__stop_token/atomic_unique_lock.h>
+#include <__stop_token/intrusive_list_view.h>
+#include <__stop_token/intrusive_shared_ptr.h>
 #include <__stop_token/stop_callback.h>
 #include <__stop_token/stop_source.h>
+#include <__stop_token/stop_state.h>
 #include <__stop_token/stop_token.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 #  error "<stop_token> is not supported since libc++ has been configured without support for threads."
 #endif
 
 #endif // _LIBCPP_STOP_TOKEN

libcxx/include/string

 #include <__fwd/string.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/addressof.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 <__memory_resource/polymorphic_allocator.h>
 #include <__string/char_traits.h>
+#include <__string/constexpr_c_functions.h>
 #include <__string/extern_template_lists.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_standard_layout.h>

libcxx/include/thread

 template <class Clock, class Duration>
 void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
 
 template <class Rep, class Period>
 void sleep_for(const chrono::duration<Rep, Period>& rel_time);
 
 }  // this_thread
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__thread/formatter.h>
+#include <__thread/poll_with_backoff.h>
 #include <__thread/this_thread.h>
 #include <__thread/thread.h>
+#include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <version>
 
 // standard-mandated includes
 
 // [thread.syn]
 #include <compare>
 

libcxx/include/tuple

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__compare/common_comparison_category.h>
 #include <__compare/synth_three_way.h>
 #include <__config>
 #include <__functional/invoke.h>
 #include <__fwd/array.h>
+#include <__fwd/get.h>
+#include <__fwd/tuple.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
+#include <__tuple/make_tuple_types.h>
+#include <__tuple/pair_like.h>
+#include <__tuple/sfinae_helpers.h>
+#include <__tuple/tuple_element.h>
+#include <__tuple/tuple_indices.h>
+#include <__tuple/tuple_like.h>
+#include <__tuple/tuple_like_ext.h>
+#include <__tuple/tuple_size.h>
+#include <__tuple/tuple_types.h>
 #include <__type_traits/apply_cv.h>
 #include <__type_traits/common_reference.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/copy_cvref.h>
 #include <__type_traits/disjunction.h>
 #include <__type_traits/is_arithmetic.h>

libcxx/include/type_traits

 #include <__fwd/hash.h> // This is https://llvm.org/PR56938
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_cv.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/add_volatile.h>
 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/aligned_union.h>
 #include <__type_traits/alignment_of.h>
 #include <__type_traits/apply_cv.h>
 #include <__type_traits/can_extract_key.h>
 #include <__type_traits/common_reference.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/conjunction.h>
+#include <__type_traits/copy_cv.h>
+#include <__type_traits/copy_cvref.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/dependent_type.h>
 #include <__type_traits/disjunction.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/extent.h>
 #include <__type_traits/has_unique_object_representation.h>
 #include <__type_traits/has_virtual_destructor.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/invoke.h>
 #include <__type_traits/is_abstract.h>
 #include <__type_traits/is_aggregate.h>
+#include <__type_traits/is_allocator.h>
+#include <__type_traits/is_always_bitcastable.h>
 #include <__type_traits/is_arithmetic.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_base_of.h>
 #include <__type_traits/is_bounded_array.h>
 #include <__type_traits/is_callable.h>
 #include <__type_traits/is_char_like_type.h>
 #include <__type_traits/is_class.h>
 #include <__type_traits/is_compound.h>
 #include <__type_traits/is_const.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_copy_assignable.h>
 #include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_core_convertible.h>
 #include <__type_traits/is_default_constructible.h>
 #include <__type_traits/is_destructible.h>
 #include <__type_traits/is_empty.h>
 #include <__type_traits/is_enum.h>
+#include <__type_traits/is_equality_comparable.h>
+#include <__type_traits/is_execution_policy.h>
 #include <__type_traits/is_final.h>
 #include <__type_traits/is_floating_point.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_fundamental.h>
 #include <__type_traits/is_implicitly_default_constructible.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_literal_type.h>
 #include <__type_traits/is_member_function_pointer.h>

 #include <__type_traits/is_nothrow_destructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_nothrow_move_constructible.h>
 #include <__type_traits/is_null_pointer.h>
 #include <__type_traits/is_object.h>
 #include <__type_traits/is_pod.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_polymorphic.h>
+#include <__type_traits/is_primary_template.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_reference_wrapper.h>
 #include <__type_traits/is_referenceable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_scalar.h>
 #include <__type_traits/is_scoped_enum.h>
 #include <__type_traits/is_signed.h>
+#include <__type_traits/is_signed_integer.h>
 #include <__type_traits/is_specialization.h>
 #include <__type_traits/is_standard_layout.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/is_trivial.h>
 #include <__type_traits/is_trivially_assignable.h>
 #include <__type_traits/is_trivially_constructible.h>
 #include <__type_traits/is_trivially_copy_assignable.h>
 #include <__type_traits/is_trivially_copy_constructible.h>
 #include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/is_trivially_default_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/is_trivially_lexicographically_comparable.h>
 #include <__type_traits/is_trivially_move_assignable.h>
 #include <__type_traits/is_trivially_move_constructible.h>
 #include <__type_traits/is_unbounded_array.h>
 #include <__type_traits/is_union.h>
 #include <__type_traits/is_unsigned.h>
+#include <__type_traits/is_unsigned_integer.h>
+#include <__type_traits/is_valid_expansion.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/is_volatile.h>
+#include <__type_traits/lazy.h>
+#include <__type_traits/make_32_64_or_128_bit.h>
 #include <__type_traits/make_const_lvalue_ref.h>
 #include <__type_traits/make_signed.h>
 #include <__type_traits/make_unsigned.h>
 #include <__type_traits/maybe_const.h>
+#include <__type_traits/nat.h>
 #include <__type_traits/negation.h>
+#include <__type_traits/noexcept_move_assign_container.h>
+#include <__type_traits/operation_traits.h>
+#include <__type_traits/predicate_traits.h>
+#include <__type_traits/promote.h>
 #include <__type_traits/rank.h>
 #include <__type_traits/remove_all_extents.h>
 #include <__type_traits/remove_const.h>
 #include <__type_traits/remove_const_ref.h>
 #include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_extent.h>
 #include <__type_traits/remove_pointer.h>
 #include <__type_traits/remove_reference.h>
 #include <__type_traits/remove_volatile.h>
 #include <__type_traits/result_of.h>
+#include <__type_traits/strip_signature.h>
 #include <__type_traits/type_identity.h>
+#include <__type_traits/type_list.h>
 #include <__type_traits/underlying_type.h>
 #include <__type_traits/unwrap_ref.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <cstddef>
 #include <cstdint>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_TYPE_TRAITS

libcxx/include/utility

struct in_place_index_t {
     explicit in_place_index_t() = default;
   };
 template <size_t I>
   inline constexpr in_place_index_t<I> in_place_index{};
 
 // [utility.underlying], to_underlying
 template <class T>
     constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++23
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__fwd/pair.h>
 #include <__utility/as_const.h>
 #include <__utility/auto_cast.h>
 #include <__utility/cmp.h>
+#include <__utility/convert_to_integral.h>
 #include <__utility/declval.h>
 #include <__utility/exception_guard.h>
 #include <__utility/exchange.h>
 #include <__utility/forward.h>
 #include <__utility/forward_like.h>
 #include <__utility/in_place.h>
 #include <__utility/integer_sequence.h>
+#include <__utility/is_pointer_in_range.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/priority_tag.h>
 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
+#include <__utility/terminate_on_exception.h>
 #include <__utility/to_underlying.h>
 #include <__utility/unreachable.h>
 #include <version>
 
 // standard-mandated includes
 
 // [utility.syn]
 #include <compare>

libcxx/modules/std/type_traits.cppm

export namespace std {
 
   using std::is_nothrow_swappable;
   using std::is_nothrow_swappable_with;
 
   using std::is_nothrow_destructible;
 
   //  using std::is_implicit_lifetime;
 
+  using std::is_execution_policy;
+
   using std::has_virtual_destructor;
 
   using std::has_unique_object_representations;
 
   // using std::reference_constructs_from_temporary;
   // using std::reference_converts_from_temporary;
 
   // [meta.unary.prop.query], type property queries
export namespace std {
   using std::is_pointer_v;
   using std::is_rvalue_reference_v;
   using std::is_union_v;
   using std::is_void_v;
 
   // [meta.unary.comp], composite type categories
   using std::is_arithmetic_v;
   using std::is_compound_v;
   using std::is_fundamental_v;
   using std::is_member_pointer_v;
   using std::is_object_v;
   using std::is_reference_v;
   using std::is_scalar_v;
 
   // [meta.unary.prop], type properties
   using std::has_unique_object_representations_v;
   using std::has_virtual_destructor_v;

libcxx/test/libcxx/transitive_includes/cxx03.csv

 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
 barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
-barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
 barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd

 tuple iosfwd
 tuple new
 tuple type_traits
 tuple typeinfo
 tuple utility
 tuple version
 type_traits cstddef
 type_traits cstdint
+type_traits limits
+type_traits new
 type_traits version
 typeindex compare
 typeindex iosfwd
 typeindex new
 typeindex typeinfo
 typeindex utility
 typeindex version
 typeinfo cstddef

libcxx/test/libcxx/transitive_includes/cxx11.csv

 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
 barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
-barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
 barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd

 tuple iosfwd
 tuple new
 tuple type_traits
 tuple typeinfo
 tuple utility
 tuple version
 type_traits cstddef
 type_traits cstdint
+type_traits limits
+type_traits new
 type_traits version
 typeindex compare
 typeindex iosfwd
 typeindex new
 typeindex typeinfo
 typeindex utility
 typeindex version
 typeinfo cstddef

libcxx/test/libcxx/transitive_includes/cxx14.csv

 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
 barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
-barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
 barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd

 tuple iosfwd
 tuple new
 tuple type_traits
 tuple typeinfo
 tuple utility
 tuple version
 type_traits cstddef
 type_traits cstdint
+type_traits limits
+type_traits new
 type_traits version
 typeindex compare
 typeindex iosfwd
 typeindex new
 typeindex typeinfo
 typeindex utility
 typeindex version
 typeinfo cstddef

libcxx/test/libcxx/transitive_includes/cxx17.csv

 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
 barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
-barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
 barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd

 tuple iosfwd
 tuple new
 tuple type_traits
 tuple typeinfo
 tuple utility
 tuple version
 type_traits cstddef
 type_traits cstdint
+type_traits limits
+type_traits new
 type_traits version
 typeindex compare
 typeindex iosfwd
 typeindex new
 typeindex typeinfo
 typeindex utility
 typeindex version
 typeinfo cstddef

libcxx/test/libcxx/transitive_includes/cxx20.csv

 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
 barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
-barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant
 barrier version
 bit cstdint
 bit cstdlib
 bit iosfwd

 tuple iosfwd
 tuple new
 tuple type_traits
 tuple typeinfo
 tuple utility
 tuple version
 type_traits cstddef
 type_traits cstdint
+type_traits limits
+type_traits new
 type_traits version
 typeindex compare
 typeindex iosfwd
 typeindex new
 typeindex typeinfo
 typeindex utility
 typeindex version
 typeinfo cstddef

libcxx/test/libcxx/transitive_includes/cxx23.csv

 mdspan cinttypes
 mdspan concepts
 mdspan cstddef
 mdspan limits
 mdspan span
 memory compare
 memory cstddef
 memory cstdint
+memory cstdlib
 memory cstring
 memory initializer_list
 memory iosfwd
 memory limits
 memory new
 memory stdexcept
 memory tuple
 memory typeinfo

 thread string_view
 thread tuple
 thread version
 tuple compare
 tuple cstddef
 tuple version
 type_traits cstddef
 type_traits cstdint
+type_traits limits
+type_traits new
 type_traits version
 typeindex compare
 typeindex typeinfo
 typeindex version
 typeinfo cstddef
 typeinfo cstdint
 unordered_map cmath
 unordered_map compare

libcxx/test/libcxx/transitive_includes/cxx26.csv

 mdspan cinttypes
 mdspan concepts
 mdspan cstddef
 mdspan limits
 mdspan span
 memory compare
 memory cstddef
 memory cstdint
+memory cstdlib
 memory cstring
 memory initializer_list
 memory iosfwd
 memory limits
 memory new
 memory stdexcept
 memory tuple
 memory typeinfo

 thread string_view
 thread tuple
 thread version
 tuple compare
 tuple cstddef
 tuple version
 type_traits cstddef
 type_traits cstdint
+type_traits limits
+type_traits new
 type_traits version
 typeindex compare
 typeindex typeinfo
 typeindex version
 typeinfo cstddef
 typeinfo cstdint
 unordered_map cmath
 unordered_map compare