[libc++][Modules] Make module exports consistent with header includes

[iana]

Summary

Some modules export modules that they don't import (i.e. that their header doesn't directly include). That sometimes works when the exported submodule is in the same module, but when the std mega module is broken up (D144322), some of the exports stop working. Make the exports and includes consistent, either by adding includes for the exports, or by removing exports for missing includes.

The concepts.equality_comparable export in std.iterator.__iterator.concepts isn't doing anything because 1) it's resolved as std.iterator.__iterator.concepts.equality_comparable and 2) there's a __concepts submodule in between std.concepts and equality_comparable. Fix it to be std.concepts.__concepts.equality_comparable.

<span> is listed in both std.span and std.experimental.span. Delete the latter module.
There is no __errc module or header, so remove that export from std.system_error.

[Mordante]

libcxx/include/__format/format_context.h

24

I doubt this is needed, this is part of <locale> and should be exported by <locale>. When this is really needed it should be moved to line 31 in the _LIBCPP_HAS_NO_LOCALIZATION. Otherwise the CI will fail.

libcxx/include/cwchar

113

Is this really needed, it looks weird; C headers should be independent.

libcxx/include/mdspan

64–65

Can you move these to the __mdspan/extents.h where the are really needed?

libcxx/include/string_view

230

The header does not use initializer_list why is it needed?

libcxx/utils/libcxx/test/header_information.py

76

I really like to see comment why this file is in this list.

[iana]

Reordered in the stack since the exports are now needed to revert some of the added includes that don't work.

[iana]

libcxx/include/__format/format_context.h

24

I added this because std.format.__format.format_context exports __locale (aka std.__locale). This currently works because they're in the same top level module, but when __format/format_context.h and __locale belong to different top level modules, the export can have no effect. (Sometimes it works and sometimes it doesn't. I think if the export is transitively included by one of the module's headers then it does work, but that's fragile.) Most of the includes added in this review are due to similar circumstances: the module for the header was exporting the module for the include. Maybe not all of the exports need to be there, but it's too difficult to track down which ones are necessary after the mega module breakup.

[iana]

Fix unit tests

[iana]

Fix unit tests, reorder in the stack

[iana]

Re-order the stack again

[iana]

More CI fixes

[iana]

Add a comment to header_information.py explaining why __iterator/readable_traits.h is a private textual header.

[ldionne]

libcxx/include/__algorithm/iterator_operations.h

23

Let's move the definition of iter_value_t from libcxx/include/__iterator/readable_traits.h to libcxx/include/__iterator/iterator_traits.h and fix up the existing includes of <__iterator/readable_traits.h>. This will remove the dependency of readable_traits.h on iterator_traits.h. This can be done in a separate patch.

libcxx/include/__algorithm/ranges_partial_sort.h

12

I think we want to *not* include this header and instead remove export algorithm.__algorithm.in_out_result from ranges_partial_sort (but not for ranges_partial_sort_copy and others).

Basically I think adding that export was a mistake that was made in https://reviews.llvm.org/D136711.

libcxx/include/__algorithm/ranges_partial_sort_copy.h

12

I think this one shouldn't be added, but instead we should change export algorithm.__algorithm.in_out_out_result to export algorithm.__algorithm.in_out_result in module ranges_partial_sort_copy.

libcxx/include/__chrono/high_resolution_clock.h

15

I think we don't want to add this one, but instead we want to

diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index d49e339f2fbb..bac76a70ff4f 100644
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -763,7 +763,6 @@ module std [system] {
         private header "__chrono/high_resolution_clock.h"
         export steady_clock
         export system_clock
-        export time_point
       }
       module literals               { private header "__chrono/literals.h" }
       module month                  { private header "__chrono/month.h" }
@@ -778,8 +777,14 @@ module std [system] {
         private header "__chrono/parser_std_format_spec.h"
       }
       module statically_widen       { private header "__chrono/statically_widen.h" }
-      module steady_clock           { private header "__chrono/steady_clock.h" }
-      module system_clock           { private header "__chrono/system_clock.h" }
+      module steady_clock           {
+        private header "__chrono/steady_clock.h"
+        export time_point
+      }
+      module system_clock           {
+        private header "__chrono/system_clock.h"
+        export time_point
+      }
       module time_point             { private header "__chrono/time_point.h" }
       module weekday                { private header "__chrono/weekday.h" }
       module year                   { private header "__chrono/year.h" }

libcxx/include/__filesystem/path.h

17

This one is definitely correct, it was a missing include.

libcxx/include/__format/format_context.h

24

Instead, I think locale should export __locale and format_context should only export locale, not export __locale.

libcxx/include/__ranges/all.h

14–15

Those don't make sense to me but I can't figure out what's wrong. The solution *should* be to remove the exports from module all but it doesn't work for some reason.

libcxx/include/__system_error/error_condition.h

15

This is adding a missing include -- obviously correct.

libcxx/utils/libcxx/test/header_information.py

148–151

Is this still going to be required after we make __iterator/readable_traits.h a standalone header?

[ldionne]

libcxx/utils/find_transitive_includes.py

2

This script doesn't seem to be used in this review, is there any reason why it's being added (or added right now)?

[iana]

Review feedback, split the review into 3

[iana]

libcxx/include/cwchar

113

I think it was transitively included, but cwchar explicitly exports the module, so it needs to include the header.

libcxx/include/string_view

230

string_view's module explicitly exports it, and this one I'm pretty sure wasn't being transitively included. So this export would definitely break without the include being added.

[iana]

Fix the std.concepts.__concepts.equality_comparable in std.iterator.__iterator.concepts

[iana]

Rebase

[ldionne]

libcxx/include/__memory/concepts.h

21

Why is this one needed?

libcxx/include/cwchar

113

Instead, what happens if we remove export depr.stdio_h from module cwchar? This seems like a better approach to me?

libcxx/include/string_view

230

I think we want to remove the include and also remove the export initializer_list from module string_view. Some headers are specified to include <initializer_list>, but <string_view> isn't. I suspect the export was added incorrectly.

libcxx/include/tgmath.h

27–28

What happens if we remove the exports instead? Our "C compatibility" headers are normally just #include_nexting the C library header, and we should strive to keep them as close as possible to that.

[iana]

libcxx/include/cwchar

113

I'll try that with the rest of these. I've been hesitant to remove the exports because their lack causes linker errors post-module-split that are sensitive to exactly what gets included and which templates are used. The CI catches a lot of them, but probably not all. Maybe world building everything at Apple will shake out the rest of them, I was just going for a more conservative approach and keeping what was there working.

libcxx/utils/libcxx/test/header_information.py

148–151

It will be required in a later change, but not this one anymore.

[iana]

Remove some of the added includes, and instead remove the associated exports

[iana]

The CI fails when __memory/concepts.h doesnt export std.type_traits.remove_reference, so add the include with a comment instead.

[ldionne]

LGTM assuming the CI passes

libcxx/include/__algorithm/iterator_operations.h

 #include <__iterator/advance.h>
 #include <__iterator/distance.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
-#include <__iterator/readable_traits.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 

libcxx/include/__algorithm/ranges_partial_sort.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___ALGORITHM_RANGES_PARTIAL_SORT_H
 #define _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_H
 
+#include <__algorithm/in_out_result.h>
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/make_projected.h>
 #include <__algorithm/partial_sort.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>

libcxx/include/__algorithm/ranges_partial_sort_copy.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___ALGORITHM_RANGES_PARTIAL_SORT_COPY_H
 #define _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_COPY_H
 
+#include <__algorithm/in_out_out_result.h>
 #include <__algorithm/in_out_result.h>
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/make_projected.h>
 #include <__algorithm/partial_sort_copy.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>

libcxx/include/__algorithm/ranges_unique_copy.h

 #include <__concepts/same_as.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.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)

libcxx/include/__chrono/high_resolution_clock.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___CHRONO_HIGH_RESOLUTION_CLOCK_H
 #define _LIBCPP___CHRONO_HIGH_RESOLUTION_CLOCK_H
 
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
+#include <__chrono/time_point.h>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__filesystem/path.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_PATH_H
 #define _LIBCPP___FILESYSTEM_PATH_H
 
 #include <__algorithm/replace.h>
 #include <__algorithm/replace_copy.h>
 #include <__availability>
 #include <__config>
+#include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__fwd/hash.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/remove_const.h>
 #include <__type_traits/remove_pointer.h>

libcxx/include/__format/format_context.h

 #include <__format/buffer.h>
 #include <__format/format_arg.h>
 #include <__format/format_arg_store.h>
 #include <__format/format_args.h>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__memory/addressof.h>
 #include <__utility/move.h>
 #include <__variant/monostate.h>
 #include <cstddef>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#include <__locale>
 #include <locale>
 #include <optional>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__format/format_functions.h

 #include <__format/formatter_floating_point.h>
 #include <__format/formatter_integer.h>
 #include <__format/formatter_pointer.h>
 #include <__format/formatter_string.h>
 #include <__format/parser_std_format_spec.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <__variant/monostate.h>
 #include <array>
 #include <string>
 #include <string_view>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #include <locale>
 #endif

libcxx/include/__format/format_string.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___FORMAT_FORMAT_STRING_H
 #define _LIBCPP___FORMAT_FORMAT_STRING_H
 
 #include <__assert>
 #include <__config>
 #include <__format/format_error.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <cstddef>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__format/formatter_output.h

 #include <__format/buffer.h>
 #include <__format/concepts.h>
 #include <__format/escaped_output_table.h>
 #include <__format/formatter.h>
 #include <__format/parser_std_format_spec.h>
 #include <__format/unicode.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <__system_error/errc.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstddef>
 #include <string>
 #include <string_view>
 

libcxx/include/__format/parser_std_format_spec.h

 #include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_error.h>
 #include <__format/format_parse_context.h>
 #include <__format/format_string.h>
 #include <__format/unicode.h>
 #include <__format/width_estimation_table.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <__memory/addressof.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/is_trivially_copyable.h>
 #include <__variant/monostate.h>
 #include <cstdint>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__format/unicode.h

 #define _LIBCPP___FORMAT_UNICODE_H
 
 #include <__assert>
 #include <__bit/countl.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/extended_grapheme_cluster_table.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__iterator/common_iterator.h

 #include <__concepts/equality_comparable.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__memory/addressof.h>
 #include <__type_traits/is_pointer.h>
 #include <__utility/declval.h>
 #include <variant>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__iterator/concepts.h

 #include <__concepts/same_as.h>
 #include <__concepts/semiregular.h>
 #include <__concepts/totally_ordered.h>
 #include <__config>
 #include <__functional/invoke.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__memory/pointer_traits.h>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/common_reference.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>

libcxx/include/__iterator/counted_iterator.h

 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__memory/pointer_traits.h>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/conditional.h>
 #include <__utility/move.h>
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__iterator/iter_swap.h

 #define _LIBCPP___ITERATOR_ITER_SWAP_H
 
 #include <__concepts/class_or_enum.h>
 #include <__concepts/swappable.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__iterator/iterator_with_data.h

 #include <__compare/compare_three_way_result.h>
 #include <__compare/three_way_comparable.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 20
 

libcxx/include/__iterator/move_iterator.h

 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_sentinel.h>
-#include <__iterator/readable_traits.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_reference.h>

libcxx/include/__iterator/reverse_iterator.h

 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
-#include <__iterator/readable_traits.h>
 #include <__iterator/segmented_iterator.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/subrange.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_assignable.h>

libcxx/include/__memory/concepts.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___MEMORY_CONCEPTS_H
 #define _LIBCPP___MEMORY_CONCEPTS_H
 
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__memory/ranges_construct_at.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___MEMORY_RANGES_CONSTRUCT_AT_H
 #define _LIBCPP___MEMORY_RANGES_CONSTRUCT_AT_H
 
 #include <__concepts/destructible.h>
 #include <__config>
 #include <__iterator/incrementable_traits.h>
-#include <__iterator/readable_traits.h>
+#include <__iterator/iterator_traits.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>

libcxx/include/__memory/ranges_uninitialized_algorithms.h

 
 #include <__algorithm/in_out_result.h>
 #include <__concepts/constructible.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.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 <__type_traits/remove_reference.h>
 #include <__utility/move.h>
 #include <new>

libcxx/include/__ranges/access.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___RANGES_ACCESS_H
 #define _LIBCPP___RANGES_ACCESS_H
 
 #include <__concepts/class_or_enum.h>
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/auto_cast.h>
 #include <__utility/declval.h>
 #include <cstddef>

libcxx/include/__ranges/all.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___RANGES_ALL_H
 #define _LIBCPP___RANGES_ALL_H
 
 #include <__config>
+#include <__functional/compose.h>
+#include <__functional/perfect_forward.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/owning_view.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/ref_view.h>
 #include <__type_traits/decay.h>

libcxx/include/__ranges/concepts.h

 #include <__concepts/constructible.h>
 #include <__concepts/movable.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>

libcxx/include/__ranges/rbegin.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___RANGES_RBEGIN_H
 #define _LIBCPP___RANGES_RBEGIN_H
 
 #include <__concepts/class_or_enum.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__ranges/access.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/auto_cast.h>
 

libcxx/include/__ranges/rend.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___RANGES_REND_H
 #define _LIBCPP___RANGES_REND_H
 
 #include <__concepts/class_or_enum.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__ranges/access.h>
 #include <__ranges/rbegin.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/auto_cast.h>

libcxx/include/__ranges/transform_view.h

 #include <__concepts/convertible_to.h>
 #include <__concepts/copyable.h>
 #include <__concepts/derived_from.h>
 #include <__concepts/equality_comparable.h>
 #include <__concepts/invocable.h>
 #include <__config>
 #include <__functional/bind_back.h>
 #include <__functional/invoke.h>
+#include <__functional/perfect_forward.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/copyable_box.h>
 #include <__ranges/empty.h>

libcxx/include/__system_error/error_condition.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___SYSTEM_ERROR_ERROR_CONDITION_H
 #define _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H
 
 #include <__compare/ordering.h>
 #include <__config>
+#include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__system_error/errc.h>
 #include <__system_error/error_category.h>
 #include <cstddef>
 #include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/cwchar

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/apply_cv.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
 #include <cwctype>
+#include <stdio.h>
 
 #include <wchar.h>
 
 #ifndef _LIBCPP_WCHAR_H
 #   error <cwchar> tried including <wchar.h> but didn't find libc++'s <wchar.h> header. \
           This usually means that your header search paths are not configured properly. \
           The header search paths should contain the C++ Standard Library headers before \
           any C Standard Library, and you are probably using compiler flags that make that \

libcxx/include/iterator

 #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/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>

libcxx/include/mdspan

 }
 */
 
 #ifndef _LIBCPP_MDSPAN
 #define _LIBCPP_MDSPAN
 
 #include <__config>
 #include <__mdspan/extents.h>
+#include <array>
+#include <span>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_MDSPAN

libcxx/include/module.modulemap.in

module algorithm {
     module __algorithm {
       module adjacent_find                   { private header "__algorithm/adjacent_find.h" }
       module all_of                          { private header "__algorithm/all_of.h" }
       module any_of                          { private header "__algorithm/any_of.h" }
       module binary_search                   { private header "__algorithm/binary_search.h" }
       module clamp                           { private header "__algorithm/clamp.h" }
       module comp                            { private header "__algorithm/comp.h" }
       module comp_ref_type                   { private header "__algorithm/comp_ref_type.h" }
-      module copy                            { private header "__algorithm/copy.h" }
+      module copy                            {
+        private header "__algorithm/copy.h"
+        export algorithm.__algorithm.copy_move_common
+      }
       module copy_backward                   { private header "__algorithm/copy_backward.h" }
       module copy_if                         { private header "__algorithm/copy_if.h" }
-      module copy_move_common                { private header "__algorithm/copy_move_common.h" }
+      module copy_move_common                {
+        private header "__algorithm/copy_move_common.h"
+        export type_traits.is_trivially_copyable
+      }
       module copy_n                          { private header "__algorithm/copy_n.h" }
       module count                           { private header "__algorithm/count.h" }
       module count_if                        { private header "__algorithm/count_if.h" }
       module equal                           { private header "__algorithm/equal.h" }
       module equal_range                     { private header "__algorithm/equal_range.h" }
       module fill                            { private header "__algorithm/fill.h" }
       module fill_n                          { private header "__algorithm/fill_n.h" }
       module find                            { private header "__algorithm/find.h" }
module __algorithm {
       module shift_left                      { private header "__algorithm/shift_left.h" }
       module shift_right                     { private header "__algorithm/shift_right.h" }
       module shuffle                         { private header "__algorithm/shuffle.h" }
       module sift_down                       { private header "__algorithm/sift_down.h" }
       module sort                            { private header "__algorithm/sort.h" }
       module sort_heap                       { private header "__algorithm/sort_heap.h" }
       module stable_partition                { private header "__algorithm/stable_partition.h" }
       module stable_sort                     { private header "__algorithm/stable_sort.h" }
-      module swap_ranges                     { private header "__algorithm/swap_ranges.h" }
+      module swap_ranges                     {
+        private header "__algorithm/swap_ranges.h"
+        export algorithm.__algorithm.iterator_operations
+      }
       module three_way_comp_ref_type         { private header "__algorithm/three_way_comp_ref_type.h" }
       module transform                       { private header "__algorithm/transform.h" }
       module unique                          { private header "__algorithm/unique.h" }
       module unique_copy                     { private header "__algorithm/unique_copy.h" }
-      module unwrap_iter                     { private header "__algorithm/unwrap_iter.h" }
+      module unwrap_iter                     {
+        private header "__algorithm/unwrap_iter.h"
+        export iterator.__iterator.iterator_traits
+      }
       module unwrap_range {
         private header "__algorithm/unwrap_range.h"
         export utility.__utility.pair
       }
       module upper_bound                     { private header "__algorithm/upper_bound.h" }
     }
   }
   module any {
module concepts {
 
     module __concepts {
       module arithmetic                 { private header "__concepts/arithmetic.h" }
       module assignable                 { private header "__concepts/assignable.h" }
       module boolean_testable           { private header "__concepts/boolean_testable.h" }
       module class_or_enum              { private header "__concepts/class_or_enum.h" }
       module common_reference_with      { private header "__concepts/common_reference_with.h" }
       module common_with                { private header "__concepts/common_with.h" }
-      module constructible              { private header "__concepts/constructible.h" }
+      module constructible              {
+        private header "__concepts/constructible.h"
+        export concepts.__concepts.destructible
+      }
       module convertible_to             { private header "__concepts/convertible_to.h" }
       module copyable                   { private header "__concepts/copyable.h" }
       module derived_from               { private header "__concepts/derived_from.h" }
-      module destructible               { private header "__concepts/destructible.h" }
+      module destructible               {
+        private header "__concepts/destructible.h"
+        export type_traits.is_nothrow_destructible
+      }
       module different_from             { private header "__concepts/different_from.h" }
       module equality_comparable {
         private header "__concepts/equality_comparable.h"
         export type_traits.common_reference
       }
       module invocable                  { private header "__concepts/invocable.h" }
-      module movable                    { private header "__concepts/movable.h" }
+      module movable                    {
+        private header "__concepts/movable.h"
+        export type_traits.is_object
+      }
       module predicate                  { private header "__concepts/predicate.h" }
       module regular                    { private header "__concepts/regular.h" }
       module relation                   { private header "__concepts/relation.h" }
       module same_as {
         private header "__concepts/same_as.h"
         export type_traits.is_same
       }
       module semiregular                { private header "__concepts/semiregular.h" }
module functional {
     module __functional {
       module binary_function            { private header "__functional/binary_function.h" }
       module binary_negate              { private header "__functional/binary_negate.h" }
       module bind                       { private header "__functional/bind.h" }
       module bind_back                  { private header "__functional/bind_back.h" }
       module bind_front                 { private header "__functional/bind_front.h" }
       module binder1st                  { private header "__functional/binder1st.h" }
       module binder2nd                  { private header "__functional/binder2nd.h" }
-      module boyer_moore_searcher       { private header "__functional/boyer_moore_searcher.h" }
+      module boyer_moore_searcher       {
+        private header "__functional/boyer_moore_searcher.h"
+        export memory.__memory.shared_ptr
+      }
       module compose                    { private header "__functional/compose.h" }
       module default_searcher           { private header "__functional/default_searcher.h" }
       module function                   { private header "__functional/function.h" }
-      module hash                       { private header "__functional/hash.h" }
+      module hash                       {
+        private header "__functional/hash.h"
+        export compat.cstdint
+        export type_traits.underlying_type
+        export utility.__utility.pair
+      }
       module hash_fwd                   { private header "__fwd/hash.h" }
       module identity                   { private header "__functional/identity.h" }
       module invoke                     {
         private header "__functional/invoke.h"
-        export type_traits
+        export *
       }
       module is_transparent             { private header "__functional/is_transparent.h" }
       module mem_fn                     { private header "__functional/mem_fn.h" }
       module mem_fun_ref                { private header "__functional/mem_fun_ref.h" }
       module not_fn                     { private header "__functional/not_fn.h" }
       module operations                 { private header "__functional/operations.h" }
-      module perfect_forward            { private header "__functional/perfect_forward.h" }
+      module perfect_forward            {
+        private header "__functional/perfect_forward.h"
+        export *
+      }
       module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
       module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
       module ranges_operations          { private header "__functional/ranges_operations.h" }
       module reference_wrapper          { private header "__functional/reference_wrapper.h" }
       module unary_function             { private header "__functional/unary_function.h" }
       module unary_negate               { private header "__functional/unary_negate.h" }
       module weak_result_type           { private header "__functional/weak_result_type.h" }
     }
module __iterator {
       module access                  { private header "__iterator/access.h" }
       module advance                 { private header "__iterator/advance.h" }
       module back_insert_iterator    { private header "__iterator/back_insert_iterator.h" }
       module bounded_iter            { private header "__iterator/bounded_iter.h" }
       module common_iterator         { private header "__iterator/common_iterator.h" }
       module cpp17_iterator_concepts { private header "__iterator/cpp17_iterator_concepts.h" }
       module concepts {
         private header "__iterator/concepts.h"
-        export concepts.equality_comparable
+        export std.concepts.__concepts.constructible
+        export std.concepts.__concepts.equality_comparable
+        export std.concepts.__concepts.movable
         export type_traits.common_reference
+        export type_traits.is_reference
+        export type_traits.remove_cvref
       }
       module counted_iterator      { private header "__iterator/counted_iterator.h" }
       module data                  { private header "__iterator/data.h" }
       module default_sentinel      { private header "__iterator/default_sentinel.h" }
-      module distance              { private header "__iterator/distance.h" }
+      module distance              {
+        private header "__iterator/distance.h"
+        export ranges.__ranges.size
+      }
       module empty                 { private header "__iterator/empty.h" }
       module erase_if_container    { private header "__iterator/erase_if_container.h" }
       module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
       module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
       module indirectly_comparable { private header "__iterator/indirectly_comparable.h" }
       module insert_iterator       { private header "__iterator/insert_iterator.h" }
       module istream_iterator      { private header "__iterator/istream_iterator.h" }
       module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
       module iter_move             { private header "__iterator/iter_move.h" }
       module iter_swap             { private header "__iterator/iter_swap.h" }
       module iterator              { private header "__iterator/iterator.h" }
-      module iterator_traits       { private header "__iterator/iterator_traits.h" }
+      module iterator_traits       {
+        private header "__iterator/iterator_traits.h"
+        export type_traits.is_primary_template
+      }
       module iterator_with_data    { private header "__iterator/iterator_with_data.h" }
       module mergeable {
         private header "__iterator/mergeable.h"
         export functional.__functional.ranges_operations
       }
       module move_iterator         { private header "__iterator/move_iterator.h" }
       module move_sentinel         { private header "__iterator/move_sentinel.h" }
       module next                  { private header "__iterator/next.h" }
       module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
       module ostreambuf_iterator   {
         private header "__iterator/ostreambuf_iterator.h"
         export iosfwd
       }
       module permutable            { private header "__iterator/permutable.h" }
       module prev                  { private header "__iterator/prev.h" }
       module projected             { private header "__iterator/projected.h" }
-      module readable_traits       {
-        private header "__iterator/readable_traits.h"
-        export __iterator.iterator_traits
-      }
+      module readable_traits       { private textual header "__iterator/readable_traits.h" }
       module reverse_access        { private header "__iterator/reverse_access.h" }
       module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
       module segmented_iterator    { private header "__iterator/segmented_iterator.h" }
       module size                  { private header "__iterator/size.h" }
       module sortable {
         private header "__iterator/sortable.h"
         export functional.__functional.ranges_operations
       }
module __memory {
       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"
         export algorithm.__algorithm.in_out_result
       }
       module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }
-      module shared_ptr                      { private header "__memory/shared_ptr.h" }
+      module shared_ptr                      {
+        private header "__memory/shared_ptr.h"
+        export memory.__memory.uninitialized_algorithms
+      }
       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 uninitialized_algorithms        {
+        private header "__memory/uninitialized_algorithms.h"
+        export algorithm.__algorithm.copy
+      }
       module uninitialized_buffer            { private header "__memory/uninitialized_buffer.h" }
-      module unique_ptr                      { private header "__memory/unique_ptr.h" }
+      module unique_ptr                      {
+        private header "__memory/unique_ptr.h"
+        export type_traits.add_lvalue_reference
+        export type_traits.is_pointer
+        export type_traits.type_identity
+      }
       module uses_allocator                  { private header "__memory/uses_allocator.h" }
       module uses_allocator_construction     { private header "__memory/uses_allocator_construction.h" }
       module voidify                         { private header "__memory/voidify.h" }
     }
   }
   module memory_resource {
     header "memory_resource"
     export *
module __ranges {
       module access                     { private header "__ranges/access.h" }
       module all                        {
         private header "__ranges/all.h"
         export functional.__functional.compose
         export functional.__functional.perfect_forward
       }
       module as_rvalue_view             { private header "__ranges/as_rvalue_view.h" }
       module common_view                { private header "__ranges/common_view.h" }
-      module concepts                   { private header "__ranges/concepts.h" }
+      module concepts                   {
+        private header "__ranges/concepts.h"
+        export iterator.__iterator.concepts
+      }
       module container_compatible_range { private header "__ranges/container_compatible_range.h" }
       module copyable_box               { private header "__ranges/copyable_box.h" }
       module counted                    {
         private header "__ranges/counted.h"
         export span
       }
       module dangling                   { private header "__ranges/dangling.h" }
       module data                       { private header "__ranges/data.h" }
module __ranges {
       module non_propagating_cache      { private header "__ranges/non_propagating_cache.h" }
       module owning_view                { private header "__ranges/owning_view.h" }
       module range_adaptor              { private header "__ranges/range_adaptor.h" }
       module rbegin                     { private header "__ranges/rbegin.h" }
       module ref_view                   { private header "__ranges/ref_view.h" }
       module rend                       { private header "__ranges/rend.h" }
       module reverse_view               { private header "__ranges/reverse_view.h" }
       module single_view                { private header "__ranges/single_view.h" }
-      module size                       { private header "__ranges/size.h" }
+      module size                       {
+        private header "__ranges/size.h"
+        export type_traits.make_unsigned
+      }
       module split_view                 { private header "__ranges/split_view.h" }
       module subrange                   {
         private header "__ranges/subrange.h"
         export subrange_fwd
       }
-      module subrange_fwd               { private header "__fwd/subrange.h" }
+      module subrange_fwd               {
+        private header "__fwd/subrange.h"
+        export iterator.__iterator.concepts
+      }
       module take_view                  { private header "__ranges/take_view.h" }
       module take_while_view            { private header "__ranges/take_while_view.h" }
       module transform_view             {
         private header "__ranges/transform_view.h"
         export functional.__functional.bind_back
         export functional.__functional.perfect_forward
       }
       module view_interface             { private header "__ranges/view_interface.h" }

   }
   module strstream {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "strstream"
     export *
   }
   module system_error {
     header "system_error"
-    export __errc
     export *
     module __system_error {
       module errc           { private header "__system_error/errc.h" }
       module error_category { private header "__system_error/error_category.h" }
       module error_code {
         private header "__system_error/error_code.h"
         export functional.__functional.hash
         export functional.__functional.unary_function
module type_traits {
     module add_cv                                    { private header "__type_traits/add_cv.h" }
     module add_lvalue_reference                      { private header "__type_traits/add_lvalue_reference.h" }
     module add_pointer                               { private header "__type_traits/add_pointer.h" }
     module add_rvalue_reference                      { private header "__type_traits/add_rvalue_reference.h" }
     module add_volatile                              { private header "__type_traits/add_volatile.h" }
     module aligned_storage                           { private header "__type_traits/aligned_storage.h" }
     module aligned_union                             { private header "__type_traits/aligned_union.h" }
     module alignment_of                              { private header "__type_traits/alignment_of.h" }
-    module apply_cv                                  { private header "__type_traits/apply_cv.h" }
+    module apply_cv                                  {
+      private header "__type_traits/apply_cv.h"
+      export is_const
+      export is_volatile
+    }
     module can_extract_key                           { private header "__type_traits/can_extract_key.h" }
     module common_reference                          { private header "__type_traits/common_reference.h" }
-    module common_type                               { private header "__type_traits/common_type.h" }
+    module common_type                               {
+      private header "__type_traits/common_type.h"
+      export utility.__utility.declval
+    }
     module conditional                               { private header "__type_traits/conditional.h" }
     module conjunction                               { private header "__type_traits/conjunction.h" }
     module copy_cv                                   { private header "__type_traits/copy_cv.h" }
     module copy_cvref                                { private header "__type_traits/copy_cvref.h" }
-    module decay                                     { private header "__type_traits/decay.h" }
+    module decay                                     {
+      private header "__type_traits/decay.h"
+      export add_pointer
+    }
     module dependent_type                            { private header "__type_traits/dependent_type.h" }
     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 invoke                                    { private header "__type_traits/invoke.h" }
+    module invoke                                    {
+      private header "__type_traits/invoke.h"
+      export conditional
+      export decay
+      export is_base_of
+      export is_core_convertible
+      export is_reference_wrapper
+      export is_void
+      export remove_cv
+    }
     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_always_bitcastable                     { private header "__type_traits/is_always_bitcastable.h" }
     module is_arithmetic {
       private header "__type_traits/is_arithmetic.h"
       export integral_constant
     }
     module is_array                                  {
       private header "__type_traits/is_array.h"
       export integral_constant
     }
     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 is_compound                               { private header "__type_traits/is_compound.h" }
     module is_const                                  { private header "__type_traits/is_const.h" }
     module is_constant_evaluated                     { private header "__type_traits/is_constant_evaluated.h" }
     module is_constructible                          { private header "__type_traits/is_constructible.h" }
-    module is_convertible                            { private header "__type_traits/is_convertible.h" }
+    module is_convertible                            {
+      private header "__type_traits/is_convertible.h"
+      export is_array
+    }
     module is_copy_assignable                        { private header "__type_traits/is_copy_assignable.h" }
     module is_copy_constructible                     { private header "__type_traits/is_copy_constructible.h" }
     module is_core_convertible                       {
       private header "__type_traits/is_core_convertible.h"
       export integral_constant
     }
     module is_default_constructible                  { private header "__type_traits/is_default_constructible.h" }
     module is_destructible                           { private header "__type_traits/is_destructible.h" }
module type_traits {
     module is_move_assignable                        { private header "__type_traits/is_move_assignable.h" }
     module is_move_constructible                     { private header "__type_traits/is_move_constructible.h" }
     module is_nothrow_assignable                     { private header "__type_traits/is_nothrow_assignable.h" }
     module is_nothrow_constructible                  { private header "__type_traits/is_nothrow_constructible.h" }
     module is_nothrow_convertible                    { private header "__type_traits/is_nothrow_convertible.h" }
     module is_nothrow_copy_assignable                { private header "__type_traits/is_nothrow_copy_assignable.h" }
     module is_nothrow_copy_constructible             { private header "__type_traits/is_nothrow_copy_constructible.h" }
     module is_nothrow_default_constructible          { private header "__type_traits/is_nothrow_default_constructible.h" }
-    module is_nothrow_destructible                   { private header "__type_traits/is_nothrow_destructible.h" }
+    module is_nothrow_destructible                   {
+      private header "__type_traits/is_nothrow_destructible.h"
+      export type_traits.is_destructible
+    }
     module is_nothrow_move_assignable                { private header "__type_traits/is_nothrow_move_assignable.h" }
-    module is_nothrow_move_constructible             { private header "__type_traits/is_nothrow_move_constructible.h" }
+    module is_nothrow_move_constructible             {
+      private header "__type_traits/is_nothrow_move_constructible.h"
+      export type_traits.is_nothrow_constructible
+    }
     module is_null_pointer                           { private header "__type_traits/is_null_pointer.h" }
-    module is_object                                 { private header "__type_traits/is_object.h" }
+    module is_object                                 {
+      private header "__type_traits/is_object.h"
+      export type_traits.is_scalar
+    }
     module is_pod                                    { private header "__type_traits/is_pod.h" }
     module is_pointer                                { private header "__type_traits/is_pointer.h" }
     module is_polymorphic                            { private header "__type_traits/is_polymorphic.h" }
-    module is_primary_template                       { private header "__type_traits/is_primary_template.h" }
+    module is_primary_template                       {
+      private header "__type_traits/is_primary_template.h"
+      export type_traits.enable_if
+    }
     module is_reference                              { private header "__type_traits/is_reference.h" }
     module is_reference_wrapper                      { private header "__type_traits/is_reference_wrapper.h" }
     module is_referenceable                          { private header "__type_traits/is_referenceable.h" }
     module is_same                                   {
       private header "__type_traits/is_same.h"
       export type_traits.integral_constant
     }
     module is_scalar                                 { private header "__type_traits/is_scalar.h" }
     module is_scoped_enum                            { private header "__type_traits/is_scoped_enum.h" }
     module is_signed                                 { private header "__type_traits/is_signed.h" }
     module is_signed_integer                         { private header "__type_traits/is_signed_integer.h" }
     module is_specialization                         { private header "__type_traits/is_specialization.h" }
     module is_standard_layout                        { private header "__type_traits/is_standard_layout.h" }
-    module is_swappable                              { private header "__type_traits/is_swappable.h" }
+    module is_swappable                              {
+      private header "__type_traits/is_swappable.h"
+      export type_traits.is_move_constructible
+    }
     module is_trivial                                { private header "__type_traits/is_trivial.h" }
     module is_trivially_assignable                   { private header "__type_traits/is_trivially_assignable.h" }
     module is_trivially_constructible                { private header "__type_traits/is_trivially_constructible.h" }
     module is_trivially_copy_assignable              { private header "__type_traits/is_trivially_copy_assignable.h" }
     module is_trivially_copy_constructible           { private header "__type_traits/is_trivially_copy_constructible.h" }
     module is_trivially_copyable                     { private header "__type_traits/is_trivially_copyable.h" }
     module is_trivially_default_constructible        { private header "__type_traits/is_trivially_default_constructible.h" }
     module is_trivially_destructible                 { private header "__type_traits/is_trivially_destructible.h" }
module is_void                                   {
       private header "__type_traits/is_void.h"
       export integral_constant
     }
     module is_volatile                               { private header "__type_traits/is_volatile.h" }
     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 make_unsigned                             {
+      private header "__type_traits/make_unsigned.h"
+      export type_traits.is_unsigned
+    }
     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 operation_traits                          { private header "__type_traits/operation_traits.h" }
     module predicate_traits                          { private header "__type_traits/predicate_traits.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_cv                                 {
+      private header "__type_traits/remove_cv.h"
+      export type_traits.remove_const
+      export type_traits.remove_volatile
+    }
     module remove_cvref                              { private header "__type_traits/remove_cvref.h" }
     module remove_extent                             { private header "__type_traits/remove_extent.h" }
     module remove_pointer                            { private header "__type_traits/remove_pointer.h" }
     module remove_reference                          { private header "__type_traits/remove_reference.h" }
     module remove_volatile                           { private header "__type_traits/remove_volatile.h" }
     module result_of                                 { private header "__type_traits/result_of.h" }
     module strip_signature                           { private header "__type_traits/strip_signature.h" }
     module type_identity                             { private header "__type_traits/type_identity.h" }
     module type_list                                 { private header "__type_traits/type_list.h" }
     module underlying_type                           {
       private header "__type_traits/underlying_type.h"
-
-      export type_traits
+      export type_traits.is_enum
     }
     module unwrap_ref                                { private header "__type_traits/unwrap_ref.h" }
     module void_t                                    { private header "__type_traits/void_t.h" }
   }
   module typeindex {
     header "typeindex"
     export *
   }
module utility {
     export *
 
     module __utility {
       module as_const               { private header "__utility/as_const.h" }
       module auto_cast              {
         private header "__utility/auto_cast.h"
         export type_traits.decay
       }
-      module cmp                    { private header "__utility/cmp.h" }
+      module cmp                    {
+        private header "__utility/cmp.h"
+        export type_traits.make_unsigned
+      }
       module convert_to_integral    { private header "__utility/convert_to_integral.h" }
       module declval                { private header "__utility/declval.h" }
       module exception_guard        { private header "__utility/exception_guard.h" }
       module exchange               { private header "__utility/exchange.h" }
       module forward                { private header "__utility/forward.h" }
       module forward_like           { private header "__utility/forward_like.h" }
       module in_place               { private header "__utility/in_place.h" }
       module integer_sequence       { private header "__utility/integer_sequence.h" }
       module is_pointer_in_range    { private header "__utility/is_pointer_in_range.h" }
-      module move                   { private header "__utility/move.h" }
-      module pair                   { private header "__utility/pair.h" }
+      module move                   {
+        private header "__utility/move.h"
+        export type_traits.is_copy_constructible
+        export type_traits.is_nothrow_move_constructible
+        export type_traits.remove_reference
+      }
+      module pair                   {
+        private header "__utility/pair.h"
+        export ranges.__ranges.subrange_fwd
+        export type_traits.is_assignable
+        export type_traits.is_constructible
+        export type_traits.is_convertible
+        export type_traits.is_copy_assignable
+        export type_traits.is_move_assignable
+        export type_traits.is_nothrow_copy_constructible
+        export type_traits.is_nothrow_default_constructible
+        export type_traits.is_nothrow_move_assignable
+      }
       module pair_fwd               { private header "__fwd/pair.h" }
       module piecewise_construct    { private header "__utility/piecewise_construct.h" }
       module priority_tag           { private header "__utility/priority_tag.h" }
       module rel_ops                { private header "__utility/rel_ops.h" }
-      module swap                   { private header "__utility/swap.h" }
+      module swap                   {
+        private header "__utility/swap.h"
+        export type_traits.is_swappable
+      }
       module terminate_on_exception { private header "__utility/terminate_on_exception.h" }
       module to_underlying          { private header "__utility/to_underlying.h" }
       module unreachable            { private header "__utility/unreachable.h" }
     }
   }
   module valarray {
     header "valarray"
     export initializer_list
module experimental {
     module simd {
       header "experimental/simd"
       export *
     }
     module set {
       header "experimental/set"
       export *
     }
-    module span {
-      header "span"
-      export *
-    }
     module string {
       header "experimental/string"
       export *
     }
     module type_traits {
       header "experimental/type_traits"
       export *
     }

libcxx/include/string_view

 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__fwd/string_view.h>
 #include <__iterator/bounded_iter.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__string/char_traits.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_standard_layout.h>
 #include <__type_traits/is_trivial.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
 #include <__type_traits/type_identity.h>
 #include <cstddef>
+#include <initializer_list>
 #include <iosfwd>
 #include <limits>
 #include <stdexcept>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/tgmath.h

 
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef __cplusplus
+#  include <ccomplex>
+#  include <cmath>
 #  include <ctgmath>
 #else
 #  if __has_include_next(<tgmath.h>)
 #    include_next <tgmath.h>
 #  endif
 #endif
 
 #endif // _LIBCPP_TGMATH_H

libcxx/test/libcxx/algorithms/pstl.robust_against_customization_points_not_working.pass.cpp

 
 // Having a customization point outside the module doesn't work, so this test is inherintly module-hostile.
 // UNSUPPORTED: modules-build
 
 // Make sure that the customization points get called properly when overloaded
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/readable_traits.h>
 #include <cassert>
 
 struct TestPolicy {};
 struct TestBackend {};
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 bool pstl_any_of_called = false;

libcxx/test/libcxx/transitive_includes/cxx03.csv

 experimental/utility utility
 experimental/vector experimental/memory_resource
 experimental/vector vector
 filesystem compare
 filesystem concepts
 filesystem cstddef
 filesystem cstdint
 filesystem cstdlib
+filesystem cstring
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem system_error
 filesystem type_traits
 filesystem version
 format array
+format cctype
+format clocale
 format cmath
 format cstddef
 format cstdint
 format cstdlib
+format cstring
+format cwchar
 format initializer_list
 format limits
 format locale
+format mutex
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

libcxx/test/libcxx/transitive_includes/cxx11.csv

 experimental/utility utility
 experimental/vector experimental/memory_resource
 experimental/vector vector
 filesystem compare
 filesystem concepts
 filesystem cstddef
 filesystem cstdint
 filesystem cstdlib
+filesystem cstring
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem system_error
 filesystem type_traits
 filesystem version
 format array
+format cctype
+format clocale
 format cmath
 format cstddef
 format cstdint
 format cstdlib
+format cstring
+format cwchar
 format initializer_list
 format limits
 format locale
+format mutex
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

libcxx/test/libcxx/transitive_includes/cxx14.csv

 experimental/utility utility
 experimental/vector experimental/memory_resource
 experimental/vector vector
 filesystem compare
 filesystem concepts
 filesystem cstddef
 filesystem cstdint
 filesystem cstdlib
+filesystem cstring
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem system_error
 filesystem type_traits
 filesystem version
 format array
+format cctype
+format clocale
 format cmath
 format cstddef
 format cstdint
 format cstdlib
+format cstring
+format cwchar
 format initializer_list
 format limits
 format locale
+format mutex
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

libcxx/test/libcxx/transitive_includes/cxx17.csv

 experimental/utility utility
 experimental/vector experimental/memory_resource
 experimental/vector vector
 filesystem compare
 filesystem concepts
 filesystem cstddef
 filesystem cstdint
 filesystem cstdlib
+filesystem cstring
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem system_error
 filesystem type_traits
 filesystem version
 format array
+format cctype
+format clocale
 format cmath
 format cstddef
 format cstdint
 format cstdlib
+format cstring
+format cwchar
 format initializer_list
 format limits
 format locale
+format mutex
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

libcxx/test/libcxx/transitive_includes/cxx20.csv

 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
 charconv type_traits
 chrono array
 chrono bit
+chrono cctype
 chrono charconv
+chrono clocale
 chrono cmath
 chrono compare
 chrono concepts
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono cstring
 chrono ctime
+chrono cwchar
 chrono limits
 chrono locale
+chrono mutex
 chrono optional
 chrono ostream
 chrono ratio
 chrono sstream
 chrono stdexcept
 chrono string
 chrono string_view
 chrono tuple

 experimental/utility utility
 experimental/vector experimental/memory_resource
 experimental/vector vector
 filesystem compare
 filesystem concepts
 filesystem cstddef
 filesystem cstdint
 filesystem cstdlib
+filesystem cstring
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem system_error
 filesystem type_traits
 filesystem version
 format array
+format cctype
+format clocale
 format cmath
 format cstddef
 format cstdint
 format cstdlib
+format cstring
+format cwchar
 format initializer_list
 format limits
 format locale
+format mutex
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple
 format version

libcxx/test/libcxx/transitive_includes/cxx23.csv

 ccomplex complex
 charconv cerrno
 charconv cmath
 charconv cstddef
 charconv cstdint
 charconv initializer_list
 charconv limits
 chrono array
+chrono cctype
+chrono clocale
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono cstdlib
+chrono cstring
 chrono ctime
+chrono cwchar
 chrono initializer_list
 chrono limits
 chrono locale
+chrono mutex
 chrono new
 chrono optional
 chrono ostream
 chrono ratio
 chrono sstream
 chrono stdexcept
 chrono string
 chrono string_view

 experimental/unordered_set experimental/memory_resource
 experimental/unordered_set unordered_set
 experimental/utility utility
 experimental/vector experimental/memory_resource
 experimental/vector vector
 filesystem compare
 filesystem cstddef
 filesystem cstdint
+filesystem cstring
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem version
 format array
+format cctype
+format clocale
 format cmath
 format cstddef
 format cstdint
 format cstdlib
+format cstring
+format cwchar
 format initializer_list
 format limits
 format locale
+format mutex
 format new
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple

libcxx/test/libcxx/transitive_includes/cxx26.csv

 ccomplex complex
 charconv cerrno
 charconv cmath
 charconv cstddef
 charconv cstdint
 charconv initializer_list
 charconv limits
 chrono array
+chrono cctype
+chrono clocale
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono cstdlib
+chrono cstring
 chrono ctime
+chrono cwchar
 chrono initializer_list
 chrono limits
 chrono locale
+chrono mutex
 chrono new
 chrono optional
 chrono ostream
 chrono ratio
 chrono sstream
 chrono stdexcept
 chrono string
 chrono string_view

 experimental/unordered_set experimental/memory_resource
 experimental/unordered_set unordered_set
 experimental/utility utility
 experimental/vector experimental/memory_resource
 experimental/vector vector
 filesystem compare
 filesystem cstddef
 filesystem cstdint
+filesystem cstring
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem version
 format array
+format cctype
+format clocale
 format cmath
 format cstddef
 format cstdint
 format cstdlib
+format cstring
+format cwchar
 format initializer_list
 format limits
 format locale
+format mutex
 format new
 format optional
 format queue
 format stack
 format stdexcept
 format string
 format string_view
 format tuple

libcxx/utils/find_transitive_includes.py

+#===----------------------------------------------------------------------===##
+#
+# 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
+#
+#===----------------------------------------------------------------------===##
+
+import argparse
+import os
+import subprocess
+import tempfile
+import typing
+
+# Finds include paths to a header that are present in all C++ versions.
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    source_group = parser.add_mutually_exclusive_group(required=True)
+    source_group.add_argument('--source-file')
+    source_group.add_argument('--start-header')
+    parser.add_argument('--header', required=True)
+    parser.add_argument('--libcxx-include-directory', required=True)
+    parser.add_argument('--libcxx-include-target-directory')
+    parser.add_argument('--cxx-compiler', required=True)
+    parser.add_argument('--target')
+    parser.add_argument('--isysroot')
+    args = parser.parse_args()
+
+    source_file_path = args.source_file
+    delete_source = False
+    if args.start_header:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.cpp', delete=False) as source_file:
+            source_file.write('#include <')
+            source_file.write(args.start_header)
+            source_file.write('>\n')
+            source_file_path = source_file.name
+        delete_source = True
+
+    direct_includes = build_include_tree(args.cxx_compiler, args.target, args.isysroot, args.libcxx_include_directory, args.libcxx_include_target_directory, source_file_path)
+    if delete_source:
+        os.remove(source_file_path)
+
+    include_paths = find_include_paths(direct_includes, args.header)
+    if args.start_header:
+        print('Include paths from <', args.start_header, '> to <', args.header, '>', sep='')
+    else:
+        print('Include paths from "', args.source_file, '" to <', args.header, '>', sep='')
+    print_include_paths(include_paths)
+
+def build_include_tree(cxx_compiler: str, target: typing.Optional[str], isysroot: typing.Optional[str], libcxx_include_directory: str, libcxx_include_target_directory: typing.Optional[str], source_file_path: str) -> set['Header']:
+    headers = None # header objects keyed by path
+    direct_includes = None # set of the headers directly included by source_file_path
+    # includes vary by standard, so all standards need to be run, and the includes intersected.
+    for standard in ['c++98', 'c++11', 'c++14', 'c++17', 'c++20', 'c++2b']:
+        cxx_command = [cxx_compiler]
+        if target:
+            cxx_command += ['-target', target]
+        if isysroot:
+            cxx_command += ['-isysroot', isysroot]
+        cxx_command += ['-E', '-H', '-fshow-skipped-includes']
+        cxx_command.append('-std=' + standard)
+        cxx_command.append('-nostdinc++')
+        cxx_command += ['-cxx-isystem', libcxx_include_directory]
+        if libcxx_include_target_directory:
+            cxx_command += ['-cxx-isystem', libcxx_include_target_directory]
+        cxx_command.append('-w')
+        cxx_command.append(source_file_path)
+
+        # Don't require the command to succeed, some of the unit test sources will fail for C++98/C++03.
+        # It should be fine, they include the libc++ headers first and the necessary output is still produced.
+        includes = subprocess.run(cxx_command, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True).stderr
+
+        # Consider 'a' that includes 'b' and 'c', 'b' that includes 'c', and 'c' that includes
+        # nothing. All three headers have header guards. For an input file that includes all three,
+        # -H -fshow-skipped-includes will look like this.
+        # . /a
+        # .. /b
+        # ... /c
+        # .. /c
+        # . /b
+        # . /c
+        # The last three lines are skipped includes - a's include of c is skipped because c has already
+        # been seen via b, and same with the input file's includes of b and c that have already been seen
+        # via a and b. Skipped includes do not re-list any of their includes, which is why there isn't a
+        # ".. /c" under ". /b". The first time a header is seen, it will show all of its direct includes
+        # and potentially some of its transitive includes. Headers without header guards are not skipped,
+        # and can have different includes depending on the context.
+        header_stack = [] # list of tuples (level, path)
+        current_headers = {} # header objects keyed by path
+        current_direct_includes = set()
+        for line in includes.splitlines():
+            if not line.startswith('.'):
+                continue
+
+            dots, include = line.split(' ', maxsplit=1)
+            level = len(dots)
+            current_header = current_headers.setdefault(include, Header(include, libcxx_include_directory))
+
+            while header_stack and (level <= header_stack[-1][0]):
+                del header_stack[-1]
+
+            if header_stack:
+                parent_header = header_stack[-1][1]
+                parent_header.included_headers.add(current_header)
+
+            header_stack.append((level, current_header))
+            if level == 1:
+                current_direct_includes.add(current_header)
+
+        if not headers:
+            headers = current_headers
+        else:
+            # The goal of this script is to find include paths from the source to the
+            # target header that are present in all configurations so that the appropriate
+            # `export` statements can be added to the module map. Intersect the includes
+            # from all of the standards so that the export chains will make the connection
+            # in all standard versions.
+            for path, current_header in current_headers.items():
+                matching_header = headers.get(path)
+                if matching_header:
+                    matching_header.included_headers &= current_header.included_headers
+            
+        if not direct_includes:
+            direct_includes = current_direct_includes
+        else:
+            direct_includes &= current_direct_includes
+
+    return direct_includes
+
+def find_include_paths(direct_includes: set['Header'], header: str) -> list[tuple['Header']]:
+    include_paths = []
+    headers_to_ignore = set()
+    for direct_include in direct_includes:
+        includes = direct_include.included_headers
+        includes_to_follow = [includes.copy()] if includes else []
+        include_path = [direct_include]
+        
+        while includes_to_follow:
+            selected_header = includes_to_follow[-1].pop()
+            include_path.append(selected_header)
+
+            selected_header_includes_to_follow = {}
+            if selected_header.libxcxx_include_relative_path == header:
+                include_paths.append(tuple(include_path))
+            else:
+                selected_header_includes = selected_header.included_headers
+                selected_header_includes_to_follow = selected_header_includes.difference(include_path) - headers_to_ignore
+                if not selected_header_includes_to_follow:
+                    # 1. This header has no includes.
+                    # 2. This header only includes things that are already in the current
+                    #    include path (i.e. cyclical includes)
+                    # Add the header to the list of headers that can be ignored from now
+                    # on.
+                    # 3. If a later header only includes ignored headers, then the later
+                    #    header can also be ignored.
+                    headers_to_ignore.add(selected_header)
+
+            if selected_header_includes_to_follow:
+                includes_to_follow.append(selected_header_includes_to_follow)
+            else:
+                # Hit the end of the include path, peel back a level.
+                del include_path[-1]
+
+                # Peel back the completed levels.
+                while includes_to_follow and not includes_to_follow[-1]:
+                    del includes_to_follow[-1]
+                    del include_path[-1]
+    return include_paths
+
+def print_include_paths(include_paths: list[tuple['Header']]) -> None:
+    def include_path_sort_key(include_path: tuple['Header']) -> tuple[int, tuple['Header']]:
+        # This script is intended to add module exports to mirror includes, usually
+        # to bridge from one private header to another. Prefer the path with the least
+        # number of public headers so that private headers don't export a large API
+        # surface. Then prefer the shortest path to add the minimum number of exports,
+        # and finally fall back on a regular sort.
+        public_header_count = 0
+        for header in include_path:
+            if not header.is_private_libcxx_header:
+                public_header_count += 1
+        return (public_header_count, len(include_path), include_path)
+
+    for include_path in sorted(include_paths, key=include_path_sort_key):
+        for include in include_path:
+            if include.is_libxx_header:
+                print(include.libxcxx_include_relative_path)
+            else:
+                print(include.path)
+        print()
+
+class Header:
+    def __init__(self, path: str, libcxx_include_directory: str) -> None:
+        self.path = path
+        if os.path.commonpath([path, libcxx_include_directory]) == libcxx_include_directory:
+            self.is_libxx_header = True
+            self.libxcxx_include_relative_path = os.path.relpath(path, libcxx_include_directory)
+            self.is_private_libcxx_header = self.libxcxx_include_relative_path.startswith('__')
+        else:
+            self.is_libxx_header = False
+            self.libxcxx_include_relative_path = ''
+            self.is_private_libcxx_header = False
+
+        self.included_headers = set()
+
+    def __repr__(self) -> str:
+        return f'<{type(self).__name__} {self.path}>'
+
+    def __hash__(self) -> int:
+        return hash(self.path)
+
+    def __eq__(self, other) -> bool:
+        return self.path == other.path
+
+    def __ne__(self, other) -> bool:
+        return self.path != other.path
+
+    def __lt__(self, other) -> bool:
+        return self.path < other.path
+
+    def __le__(self, other) -> bool:
+        return self.path <= other.path
+
+    def __gt__(self, other) -> bool:
+        return self.path > other.path
+
+    def __ge__(self, other) -> bool:
+        return self.path >= other.path
+
+main()

libcxx/utils/libcxx/test/header_information.py

private_headers_still_public_in_modules = [
     "__debug",
     "__hash_table",
     "__threading_support",
     "__tree",
     "__undef_macros",
     "__verbose_abort",
 ]
 
+private_textual_headers = frozenset((
+    "__config",
+    "__iterator/readable_traits.h",
+))
+
 # This table was produced manually, by grepping the TeX source of the Standard's
 # library clauses for the string "#include". Each header's synopsis contains
 # explicit "#include" directives for its mandatory inclusions.
 # For example, [algorithm.syn] contains "#include <initializer_list>".
 mandatory_inclusions = {
     "algorithm": ["initializer_list"],
     "array": ["compare", "initializer_list"],
     "bitset": ["iosfwd", "string"],

 experimental_headers = sorted(
     p.relative_to(include).as_posix() for p in include.glob("experimental/[a-z]*") if is_header(p)
 )
 public_headers = toplevel_headers + experimental_headers
 private_headers = sorted(
     p.relative_to(include).as_posix() for p in include.rglob("*") if is_header(p)
                                                                      and str(p.relative_to(include)).startswith("__")
                                                                      and not p.name.startswith("pstl")
+                                                                     # Textual headers shouldn't be included directly
+                                                                     # (they're typically part of another header that
+                                                                     # was split out just for organization).
+                                                                     and str(p.relative_to(include)) not in private_textual_headers
 )