[libc++][Modules] Add missing includes and exports

[iana]

Summary

When the std mega module is broken up (D144322), it exposes several missing includes and exports.

[philnik]

There seem to be a lot of false-positives from the module map change.

libcxx/include/__algorithm/copy.h

16 ↗

(On Diff #525709)

This include is wrong. __iterator_with_data isn't used in this file.

libcxx/include/__algorithm/copy_backward.h

16 ↗

(On Diff #525709)

Same here.

libcxx/include/__algorithm/pstl_any_all_none_of.h

20

Same here.

libcxx/include/__algorithm/pstl_backend.h

13 ↗

(On Diff #525709)

This should be included through <__algorithm/pstl_backends/cpu_backend.h>.

libcxx/include/__algorithm/pstl_fill.h

21

Same here.

libcxx/include/__algorithm/pstl_find.h

21

and here.

libcxx/include/__algorithm/sort.h

16 ↗

(On Diff #525709)

This is also never used in sort.h.

libcxx/include/__locale_dir/locale_base_api/bsd_locale_fallbacks.h

16

bsd_locale_fallbacks.h should probably not be part of the module. This might not compile on all platforms.

libcxx/include/__mdspan/extents.h

22 ↗

(On Diff #525709)

<span> is already included. There shouldn't be a need to include a forward declaration.

libcxx/include/__random/discrete_distribution.h

14

This is also never used here.

[iana]

In D151475#4373291, @philnik wrote:

There seem to be a lot of false-positives from the module map change.

A lot of these were added last week, it's possible things have changed. Let me go back through the ones you pointed out.

[iana]

Review feedback, add a module for pstl_frontend_dispatch.h so that it can export __utility/forward.h

[iana]

libcxx/include/__locale_dir/locale_base_api/bsd_locale_fallbacks.h

16

It has to be part of the module because it's included by <locale>. But it doesn't compile on all platforms, so it's a textual header so that it only gets used if <locale> actually includes it.

libcxx/include/__mdspan/extents.h

22 ↗

(On Diff #525709)

That's what I thought, but I was still getting an error without it. Let me try again, I found an issue where some modules were exporting modules that they didn't include in the first place, and that seems to make clang mad.

[iana]

libcxx/include/__algorithm/pstl_backend.h

13 ↗

(On Diff #525709)

Oh, <__algorithm/pstl_backends/cpu_backend.h> doesn't include <__algorithm/pstl_backends/cpu_backends/backend.h>. Nothing does. I'll ad it there.

[iana]

Remove a few invalid exports and make a few more fixes.

[iana]

Still seeing some test failures.

libcxx/include/__algorithm/pstl_backend.h

13 ↗

(On Diff #525709)

Err, typo in my find command. Each of the individual backends include <__algorithm/pstl_backends/cpu_backends/backend.h> but none of them export it. I guess they all need to.

libcxx/include/__algorithm/sort.h

16 ↗

(On Diff #525709)

I think it is.

/Volumes/SoftwareDevelopment/Projects/llvm-project/build/generic-modules/include/c++/v1/__algorithm/sort.h:715:11: error: definition of '_ProjectedPred' must be imported from module 'std_private_algorithm_1.make_projected' before it is required
      if (__comp(*--__last, *__first))
          ^
/Volumes/SoftwareDevelopment/Projects/llvm-project/build/generic-modules/include/c++/v1/__algorithm/sort.h:855:8: note: in instantiation of function template specialization 'std::__introsort<std::_RangeAlgPolicy, std::_ProjectedPred<Less, Proj> &, T *, false>' requested here
  std::__introsort<_AlgPolicy,
       ^
/Volumes/SoftwareDevelopment/Projects/llvm-project/build/generic-modules/include/c++/v1/__algorithm/make_projected.h:31:8: note: definition here is not reachable
struct _ProjectedPred {
       ^

[iana]

I'm going to split this one up into a couple of reviews. Mostly it isn't includes that need to be added, but module exports.

libcxx/include/__algorithm/pstl_any_all_none_of.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_PSTL_ANY_ALL_NONE_OF_H
 #define _LIBCPP___ALGORITHM_PSTL_ANY_ALL_NONE_OF_H
 
+#include <__algorithm/pstl_backend.h>
 #include <__algorithm/pstl_find.h>
 #include <__algorithm/pstl_frontend_dispatch.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_execution_policy.h>
 #include <__type_traits/remove_cvref.h>
+#include <__utility/move.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 

libcxx/include/__algorithm/pstl_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_PSTL_COPY_H
 #define _LIBCPP___ALGORITHM_PSTL_COPY_H
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/pstl_transform.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_execution_policy.h>
 #include <__type_traits/is_trivially_copyable.h>
+#include <__type_traits/remove_cvref.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__algorithm/pstl_fill.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_PSTL_FILL_H
 #define _LIBCPP___ALGORITHM_PSTL_FILL_H
 
 #include <__algorithm/fill_n.h>
+#include <__algorithm/pstl_backend.h>
 #include <__algorithm/pstl_for_each.h>
 #include <__algorithm/pstl_frontend_dispatch.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/is_execution_policy.h>
 #include <__type_traits/remove_cvref.h>
+#include <__utility/move.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 

libcxx/include/__algorithm/pstl_find.h

 #define _LIBCPP___ALGORITHM_PSTL_FIND_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/find.h>
 #include <__algorithm/pstl_backend.h>
 #include <__algorithm/pstl_frontend_dispatch.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/is_execution_policy.h>
 #include <__type_traits/remove_cvref.h>
+#include <__utility/move.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 

libcxx/include/__algorithm/pstl_for_each.h

 #define _LIBCPP___ALGORITHM_PSTL_FOR_EACH_H
 
 #include <__algorithm/for_each.h>
 #include <__algorithm/for_each_n.h>
 #include <__algorithm/pstl_backend.h>
 #include <__algorithm/pstl_frontend_dispatch.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/is_execution_policy.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/void_t.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 

libcxx/include/__algorithm/pstl_transform.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_PSTL_TRANSFORM_H
 #define _LIBCPP___ALGORITHM_PSTL_TRANSFORM_H
 
 #include <__algorithm/pstl_backend.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/is_execution_policy.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/move.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 

libcxx/include/__functional/invoke.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___FUNCTIONAL_INVOKE_H
 #define _LIBCPP___FUNCTIONAL_INVOKE_H
 
 #include <__config>
 #include <__type_traits/invoke.h>
+#include <__type_traits/is_void.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__locale_dir/locale_base_api/bsd_locale_fallbacks.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // The BSDs have lots of *_l functions.  This file provides reimplementations
 // of those functions for non-BSD platforms.
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___LOCALE_LOCALE_BASE_API_BSD_LOCALE_FALLBACKS_H
 #define _LIBCPP___LOCALE_LOCALE_BASE_API_BSD_LOCALE_FALLBACKS_H
 
+#include <__locale>
 #include <__locale_dir/locale_base_api/locale_guard.h>
 #include <cstdio>
 #include <stdarg.h>
 #include <stdlib.h>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif

libcxx/include/__random/discrete_distribution.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___RANDOM_DISCRETE_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H
 
 #include <__algorithm/upper_bound.h>
 #include <__config>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cstddef>
+#include <initializer_list>
 #include <iosfwd>
 #include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__thread/poll_with_backoff.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___THREAD_POLL_WITH_BACKOFF_H
 #define _LIBCPP___THREAD_POLL_WITH_BACKOFF_H
 
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/high_resolution_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/__threading_support

 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
 # include <__external_threading>
 #elif !defined(_LIBCPP_HAS_NO_THREADS)
 
 #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
+// Some platforms require <bits/atomic_wide_counter.h> in order for
+// PTHREAD_COND_INITIALIZER to be expanded. Normally that would come
+// in via <pthread.h>, but it's a non-modular header on those platforms,
+// so libc++'s <math.h> usually absorbs atomic_wide_counter.h into the
+// module with <math.h> and makes atomic_wide_counter.h invisible.
+// Include <math.h> here to work around that.
+# include <math.h>
 # include <pthread.h>
 # include <sched.h>
 #elif defined(_LIBCPP_HAS_THREAD_API_C11)
 # include <threads.h>
 #endif
 
 #if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \
     defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) || \

libcxx/include/experimental/simd

 
 } // parallelism_v2
 } // std::experimental
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/operations.h>
+#include <__type_traits/is_unsigned.h>
+#include <__type_traits/is_volatile.h>
+#include <__type_traits/remove_const.h>
+#include <__utility/declval.h>
 #include <array>
 #include <cstddef>
 #include <experimental/__config>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/experimental/type_traits

 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 
 #if _LIBCPP_STD_VER >= 14
 
+#include <__type_traits/nat.h>
 #include <initializer_list>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS

libcxx/include/future

 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
 #include <__system_error/error_category.h>
 #include <__system_error/error_code.h>
 #include <__system_error/error_condition.h>
+#include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/alignment_of.h>
 #include <__type_traits/strip_signature.h>
+#include <__type_traits/underlying_type.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <mutex>
 #include <new>
 #include <stdexcept>
 #include <thread>
 #include <version>

libcxx/include/map

 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <tuple>
 #include <version>
 
 // standard-mandated includes
 

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_copy_constructible
+        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                           {
+        private header "__algorithm/equal.h"
+        export algorithm.__algorithm.unwrap_iter
+      }
       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 find_end                        { private header "__algorithm/find_end.h" }
       module find_first_of                   { private header "__algorithm/find_first_of.h" }
       module find_if                         { private header "__algorithm/find_if.h" }
       module find_if_not                     { private header "__algorithm/find_if_not.h" }
       module for_each                        { private header "__algorithm/for_each.h" }
       module for_each_n                      { private header "__algorithm/for_each_n.h" }
       module generate                        { private header "__algorithm/generate.h" }
       module generate_n                      { private header "__algorithm/generate_n.h" }
       module half_positive                   { private header "__algorithm/half_positive.h" }
-      module in_found_result                 { private header "__algorithm/in_found_result.h" }
+      module in_found_result                 {
+        private header "__algorithm/in_found_result.h"
+        export utility.__utility.move
+      }
       module in_fun_result                   { private header "__algorithm/in_fun_result.h" }
-      module in_in_out_result                { private header "__algorithm/in_in_out_result.h" }
-      module in_in_result                    { private header "__algorithm/in_in_result.h" }
-      module in_out_out_result               { private header "__algorithm/in_out_out_result.h" }
-      module in_out_result                   { private header "__algorithm/in_out_result.h" }
+      module in_in_out_result                {
+        private header "__algorithm/in_in_out_result.h"
+        export utility.__utility.move
+      }
+      module in_in_result                    {
+        private header "__algorithm/in_in_result.h"
+        export utility.__utility.move
+      }
+      module in_out_out_result               {
+        private header "__algorithm/in_out_out_result.h"
+        export utility.__utility.move
+      }
+      module in_out_result                   {
+        private header "__algorithm/in_out_result.h"
+        export utility.__utility.move
+      }
       module includes                        { private header "__algorithm/includes.h" }
       module inplace_merge                   { private header "__algorithm/inplace_merge.h" }
       module is_heap                         { private header "__algorithm/is_heap.h" }
       module is_heap_until                   { private header "__algorithm/is_heap_until.h" }
       module is_partitioned                  { private header "__algorithm/is_partitioned.h" }
       module is_permutation                  { private header "__algorithm/is_permutation.h" }
       module is_sorted                       { private header "__algorithm/is_sorted.h" }
       module is_sorted_until                 { private header "__algorithm/is_sorted_until.h" }
module __algorithm {
       module lower_bound                     { private header "__algorithm/lower_bound.h" }
       module make_heap                       { private header "__algorithm/make_heap.h" }
       module make_projected                  { private header "__algorithm/make_projected.h" }
       module max                             { private header "__algorithm/max.h" }
       module max_element                     { private header "__algorithm/max_element.h" }
       module merge                           { private header "__algorithm/merge.h" }
       module min                             { private header "__algorithm/min.h" }
       module min_element                     { private header "__algorithm/min_element.h" }
-      module min_max_result                  { private header "__algorithm/min_max_result.h" }
+      module min_max_result                  {
+        private header "__algorithm/min_max_result.h"
+        export utility.__utility.move
+      }
       module minmax                          {
         private header "__algorithm/minmax.h"
         export *
       }
       module minmax_element                  { private header "__algorithm/minmax_element.h" }
       module mismatch                        { private header "__algorithm/mismatch.h" }
       module move                            { private header "__algorithm/move.h" }
       module move_backward                   { private header "__algorithm/move_backward.h" }
       module next_permutation                { private header "__algorithm/next_permutation.h" }
       module none_of                         { private header "__algorithm/none_of.h" }
       module nth_element                     { private header "__algorithm/nth_element.h" }
       module partial_sort                    { private header "__algorithm/partial_sort.h" }
       module partial_sort_copy               { private header "__algorithm/partial_sort_copy.h" }
       module partition                       { private header "__algorithm/partition.h" }
       module partition_copy                  { private header "__algorithm/partition_copy.h" }
       module partition_point                 { private header "__algorithm/partition_point.h" }
       module pop_heap                        { private header "__algorithm/pop_heap.h" }
       module prev_permutation                { private header "__algorithm/prev_permutation.h" }
+      module pstl_backend {
+        private header "__algorithm/pstl_backend.h"
+        export *
+      }
       module pstl_backends_cpu_backend       {
         private header "__algorithm/pstl_backends/cpu_backend.h"
         export *
       }
       module pstl_backends_cpu_backends_any_of {
         private header "__algorithm/pstl_backends/cpu_backends/any_of.h"
+        export algorithm.__algorithm.pstl_backends_cpu_backends_backend
       }
       module pstl_backends_cpu_backends_backend {
         private header "__algorithm/pstl_backends/cpu_backends/backend.h"
         export *
       }
-      module pstl_backends_cpu_backends_fill { private header "__algorithm/pstl_backends/cpu_backends/fill.h" }
+      module pstl_backends_cpu_backends_fill {
+        private header "__algorithm/pstl_backends/cpu_backends/fill.h"
+        export algorithm.__algorithm.pstl_backends_cpu_backends_backend
+      }
       module pstl_backends_cpu_backends_find_if {
         private header "__algorithm/pstl_backends/cpu_backends/find_if.h"
+        export algorithm.__algorithm.pstl_backends_cpu_backends_backend
       }
       module pstl_backends_cpu_backends_for_each {
         private header "__algorithm/pstl_backends/cpu_backends/for_each.h"
+        export algorithm.__algorithm.pstl_backends_cpu_backends_backend
       }
       module pstl_backends_cpu_backends_serial {
-        private header "__algorithm/pstl_backends/cpu_backends/serial.h"
+        private textual header "__algorithm/pstl_backends/cpu_backends/serial.h"
       }
       module pstl_backends_cpu_backends_thread {
-        private header "__algorithm/pstl_backends/cpu_backends/thread.h"
+        private textual header "__algorithm/pstl_backends/cpu_backends/thread.h"
       }
       module pstl_backends_cpu_backends_transform {
         private header "__algorithm/pstl_backends/cpu_backends/transform.h"
+        export algorithm.__algorithm.pstl_backends_cpu_backends_backend
+      }
+      module pstl_frontend_dispatch {
+        private header "__algorithm/pstl_frontend_dispatch.h"
+        export utility.__utility.forward
       }
       module push_heap                       { private header "__algorithm/push_heap.h" }
       module ranges_adjacent_find            { private header "__algorithm/ranges_adjacent_find.h" }
       module ranges_all_of                   { private header "__algorithm/ranges_all_of.h" }
       module ranges_any_of                   { private header "__algorithm/ranges_any_of.h" }
       module ranges_binary_search {
         private header "__algorithm/ranges_binary_search.h"
+        export algorithm.__algorithm.iterator_operations
         export functional.__functional.ranges_operations
       }
       module ranges_clamp {
         private header "__algorithm/ranges_clamp.h"
         export functional.__functional.ranges_operations
       }
       module ranges_copy {
         private header "__algorithm/ranges_copy.h"
module __algorithm {
       }
       module ranges_none_of                  { private header "__algorithm/ranges_none_of.h" }
       module ranges_nth_element {
         private header "__algorithm/ranges_nth_element.h"
         export functional.__functional.ranges_operations
       }
       module ranges_partial_sort {
         private header "__algorithm/ranges_partial_sort.h"
-        export algorithm.__algorithm.in_out_result
         export functional.__functional.ranges_operations
       }
       module ranges_partial_sort_copy {
         private header "__algorithm/ranges_partial_sort_copy.h"
-        export algorithm.__algorithm.in_out_out_result
         export functional.__functional.ranges_operations
       }
       module ranges_partition                { private header "__algorithm/ranges_partition.h" }
       module ranges_partition_copy           { private header "__algorithm/ranges_partition_copy.h" }
       module ranges_partition_point          { private header "__algorithm/ranges_partition_point.h" }
       module ranges_pop_heap {
         private header "__algorithm/ranges_pop_heap.h"
         export functional.__functional.ranges_operations
module __algorithm {
       module replace_copy                    { private header "__algorithm/replace_copy.h" }
       module replace_copy_if                 { private header "__algorithm/replace_copy_if.h" }
       module replace_if                      { private header "__algorithm/replace_if.h" }
       module reverse                         { private header "__algorithm/reverse.h" }
       module reverse_copy                    { private header "__algorithm/reverse_copy.h" }
       module rotate                          { private header "__algorithm/rotate.h" }
       module rotate_copy                     { private header "__algorithm/rotate_copy.h" }
       module sample                          { private header "__algorithm/sample.h" }
-      module search                          { private header "__algorithm/search.h" }
+      module search                          {
+        private header "__algorithm/search.h"
+        export utility.__utility.pair
+      }
       module search_n                        { private header "__algorithm/search_n.h" }
       module set_difference                  { private header "__algorithm/set_difference.h" }
       module set_intersection                { private header "__algorithm/set_intersection.h" }
       module set_symmetric_difference        { private header "__algorithm/set_symmetric_difference.h" }
       module set_union                       { private header "__algorithm/set_union.h" }
       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 __chrono {
         @requires_LIBCXX_ENABLE_LOCALIZATION@
         private header "__chrono/formatter.h"
       }
       module hh_mm_ss               { private header "__chrono/hh_mm_ss.h" }
       module high_resolution_clock  {
         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" }
       module month_weekday          { private header "__chrono/month_weekday.h" }
       module monthday               { private header "__chrono/monthday.h" }
       module ostream                {
         @requires_LIBCXX_ENABLE_LOCALIZATION@
         private header "__chrono/ostream.h"
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 predicate                  { private header "__concepts/predicate.h" }
module __filesystem {
       module directory_options            { private header "__filesystem/directory_options.h" }
       module file_status                  { private header "__filesystem/file_status.h" }
       module file_time_type               { private header "__filesystem/file_time_type.h" }
       module file_type                    { private header "__filesystem/file_type.h" }
       module filesystem_error             { private header "__filesystem/filesystem_error.h" }
       module operations                   { private header "__filesystem/operations.h" }
       module path                         {
         private header "__filesystem/path.h"
-        export functional.__functional.hash
         export functional.__functional.unary_function
       }
       module path_iterator                { private header "__filesystem/path_iterator.h" }
       module perm_options                 { private header "__filesystem/perm_options.h" }
       module perms                        { private header "__filesystem/perms.h" }
       module recursive_directory_iterator { private header "__filesystem/recursive_directory_iterator.h" }
       module space_info                   { private header "__filesystem/space_info.h" }
       module u8path                       { private header "__filesystem/u8path.h" }
module __format {
       module enable_insertable               { private header "__format/enable_insertable.h" }
       module escaped_output_table            { private header "__format/escaped_output_table.h" }
       module extended_grapheme_cluster_table { private header "__format/extended_grapheme_cluster_table.h" }
       module format_arg                      { private header "__format/format_arg.h" }
       module format_arg_store                { private header "__format/format_arg_store.h" }
       module format_args                     { private header "__format/format_args.h" }
       module format_context {
         private header "__format/format_context.h"
-        export optional
-        export locale
-        export __locale
+        export *
       }
       module format_error                    { private header "__format/format_error.h" }
       module format_functions                {
         private header "__format/format_functions.h"
         export string
       }
       module format_fwd                      { private header "__format/format_fwd.h" }
       module format_parse_context            { private header "__format/format_parse_context.h" }
module __format {
       module formatter_integral              { private header "__format/formatter_integral.h" }
       module formatter_output                { private header "__format/formatter_output.h" }
       module formatter_pointer               { private header "__format/formatter_pointer.h" }
       module formatter_string                { private header "__format/formatter_string.h" }
       module formatter_tuple                 { private header "__format/formatter_tuple.h" }
       module parser_std_format_spec          { private header "__format/parser_std_format_spec.h" }
       module range_default_formatter         { private header "__format/range_default_formatter.h" }
       module range_formatter                 { private header "__format/range_formatter.h" }
-      module unicode                         { private header "__format/unicode.h" }
+      module unicode                         {
+        private header "__format/unicode.h"
+        export format.__format.extended_grapheme_cluster_table
+      }
       module width_estimation_table          { private header "__format/width_estimation_table.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
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 compose                    { private header "__functional/compose.h" }
+      module boyer_moore_searcher       {
+        private header "__functional/boyer_moore_searcher.h"
+        export memory.__memory.shared_ptr
+      }
+      module compose                    {
+        private header "__functional/compose.h"
+        export functional.__functional.perfect_forward
+      }
       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 cstdint
+      }
       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 type_traits.invoke
+        export type_traits.is_void
       }
       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 pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
module __iterator {
       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 concepts.__concepts.constructible
+      }
       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 header "__iterator/readable_traits.h" }
       module reverse_access        { private header "__iterator/reverse_access.h" }
-      module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
+      module reverse_iterator      {
+        private header "__iterator/reverse_iterator.h"
+        export iterator.__iterator.iterator_traits
+      }
       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 unreachable_sentinel  { private header "__iterator/unreachable_sentinel.h" }
       module wrap_iter             { private header "__iterator/wrap_iter.h" }

   }
   module mdspan {
     header "mdspan"
     export array
     export span
     export *
 
     module __mdspan {
-      module extents                         { private header "__mdspan/extents.h" }
+      module extents                         {
+        private header "__mdspan/extents.h"
+        export array
+        export span
+      }
     }
   }
   module memory {
     header "memory"
     export *
 
     module __memory {
       module addressof                       { private header "__memory/addressof.h" }
       module align                           { private header "__memory/align.h" }
       module aligned_alloc                   { private header "__memory/aligned_alloc.h" }
       module allocate_at_least               { private header "__memory/allocate_at_least.h" }
       module allocation_guard                { private header "__memory/allocation_guard.h" }
       module allocator                       { private header "__memory/allocator.h" }
       module allocator_arg_t                 { private header "__memory/allocator_arg_t.h" }
       module allocator_destructor            { private header "__memory/allocator_destructor.h" }
       module allocator_traits                { private header "__memory/allocator_traits.h" }
       module assume_aligned                  { private header "__memory/assume_aligned.h" }
       module auto_ptr                        { private header "__memory/auto_ptr.h" }
       module builtin_new_allocator           { private header "__memory/builtin_new_allocator.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
-      module concepts                        {
-        private header "__memory/concepts.h"
-        export type_traits.remove_reference
-      }
+      module concepts                        { private header "__memory/concepts.h" }
       module construct_at                    { private header "__memory/construct_at.h" }
       module destruct_n                      { private header "__memory/destruct_n.h" }
       module pointer_traits                  { private header "__memory/pointer_traits.h" }
       module ranges_construct_at             { private header "__memory/ranges_construct_at.h" }
       module ranges_uninitialized_algorithms {
         private header "__memory/ranges_uninitialized_algorithms.h"
         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
+        export memory.__memory.unique_ptr
+        export type_traits.is_move_constructible
+      }
       module swap_allocator                  { private header "__memory/swap_allocator.h" }
       module temp_value                      { private header "__memory/temp_value.h" }
       module temporary_buffer                { private header "__memory/temporary_buffer.h" }
-      module uninitialized_algorithms        { private header "__memory/uninitialized_algorithms.h" }
-      module unique_ptr                      { private header "__memory/unique_ptr.h" }
+      module uninitialized_algorithms        {
+        private header "__memory/uninitialized_algorithms.h"
+        export algorithm.__algorithm.copy
+      }
+      module unique_ptr                      {
+        private header "__memory/unique_ptr.h"
+        export type_traits.is_assignable
+        export type_traits.is_convertible
+      }
       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 {
     export initializer_list
     export iterator
     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
+        export ranges.__ranges.owning_view
       }
       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 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 drop_view                  { private header "__ranges/drop_view.h" }
       module drop_while_view            { private header "__ranges/drop_while_view.h" }
-      module elements_view              { private header "__ranges/elements_view.h" }
+      module elements_view              {
+        private header "__ranges/elements_view.h"
+        export tuple.tuple_like
+      }
       module empty                      { private header "__ranges/empty.h" }
       module empty_view                 { private header "__ranges/empty_view.h" }
       module enable_borrowed_range      { private header "__ranges/enable_borrowed_range.h" }
       module enable_view                { private header "__ranges/enable_view.h" }
-      module filter_view                { private header "__ranges/filter_view.h" }
+      module filter_view                {
+        private header "__ranges/filter_view.h"
+        export ranges.__ranges.range_adaptor
+      }
       module from_range                 { private header "__ranges/from_range.h" }
       module iota_view                  { private header "__ranges/iota_view.h" }
       module istream_view               {
         @requires_LIBCXX_ENABLE_LOCALIZATION@
         private header "__ranges/istream_view.h"
       }
-      module join_view                  { private header "__ranges/join_view.h" }
+      module join_view                  {
+        private header "__ranges/join_view.h"
+        export iterator.__iterator.segmented_iterator
+      }
       module lazy_split_view            { private header "__ranges/lazy_split_view.h" }
       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 split_view                 { private header "__ranges/split_view.h" }
+      module split_view                 {
+        private header "__ranges/split_view.h"
+        export ranges.__ranges.non_propagating_cache
+      }
       module subrange                   {
         private header "__ranges/subrange.h"
         export subrange_fwd
       }
       module subrange_fwd               { private header "__fwd/subrange.h" }
       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
+        export ranges.__ranges.copyable_box
       }
       module view_interface             { private header "__ranges/view_interface.h" }
       module views                      { private header "__ranges/views.h" }
       module zip_view                   { private header "__ranges/zip_view.h" }
     }
   }
   module ratio {
     header "ratio"
module __system_error {
       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 error_condition {
         private header "__system_error/error_condition.h"
-        export functional.__functional.hash
         export functional.__functional.unary_function
       }
       module system_error { private header "__system_error/system_error.h" }
 
     }
   }
   module thread {
     @requires_LIBCXX_ENABLE_THREADS@
module type_traits {
     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 can_extract_key                           { private header "__type_traits/can_extract_key.h" }
-    module common_reference                          { private header "__type_traits/common_reference.h" }
+    module common_reference                          {
+      private header "__type_traits/common_reference.h"
+      export type_traits.remove_cvref
+    }
     module common_type                               { private header "__type_traits/common_type.h" }
     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 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 type_traits.add_lvalue_reference
+      export type_traits.apply_cv
+      export type_traits.conditional
+      export type_traits.decay
+      export type_traits.enable_if
+      export type_traits.integral_constant
+      export type_traits.is_base_of
+      export type_traits.is_core_convertible
+      export type_traits.is_member_function_pointer
+      export type_traits.is_member_object_pointer
+      export type_traits.is_reference_wrapper
+      export type_traits.is_same
+      export type_traits.is_void
+      export type_traits.nat
+      export type_traits.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_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 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_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
-    }
+    module underlying_type                           { private header "__type_traits/underlying_type.h" }
     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 typeinfo {
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 move                   { private header "__utility/move.h" }
-      module pair                   { private header "__utility/pair.h" }
+      module pair                   {
+        private header "__utility/pair.h"
+        export type_traits.is_copy_assignable
+        export type_traits.is_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 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 __locale            {
     private header "__locale" export *
   }
   module __mbstate_t         { private header "__mbstate_t.h"       export * }
   module __node_handle       { private header "__node_handle"       export * }
   module __split_buffer      { private header "__split_buffer"      export * }
   module __std_mbstate_t     { private header "__std_mbstate_t.h"   export * }
   module __threading_support {         header "__threading_support" export * }
   module __tree              {         header "__tree"              export * }
-  module __undef_macros      {         header "__undef_macros"      export * }
+  module __undef_macros      { textual header "__undef_macros"      export * }
   module __verbose_abort     {         header "__verbose_abort"     export * }
 
   // This one needs to appear after __tree to work around issues with modules in Objective-C++ mode.
   module coroutine {
     header "coroutine"
     export compare
     export *
 

libcxx/include/set

 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>

libcxx/include/thread

 #include <__memory/addressof.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex/mutex.h>
 #include <__mutex/unique_lock.h>
 #include <__system_error/system_error.h>
 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_pointer.h>
 #include <__utility/forward.h>
 #include <cstddef>
 #include <cstdint>
 #include <iosfwd>
 #include <tuple>
 #include <version>
 
 // standard-mandated includes

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/sfinae_helpers.h>
 #include <__tuple/tuple_element.h>
 #include <__tuple/tuple_indices.h>
 #include <__tuple/tuple_like_ext.h>

libcxx/include/unordered_set

 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
 #include <__type_traits/is_allocator.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>