[libcxx-commits] [libcxx] Revert "[libc++][modules] Rewrite the modulemap to have fewer top-level modules (#107638)" (PR #110384)

Chris B via libcxx-commits libcxx-commits at lists.llvm.org
Sat Sep 28 16:19:29 PDT 2024


https://github.com/llvm-beanz updated https://github.com/llvm/llvm-project/pull/110384

>From df48df33d8ae5240b1eb7746ddc8128e969ca7c2 Mon Sep 17 00:00:00 2001
From: Chris Bieneman <chris.bieneman at me.com>
Date: Sat, 28 Sep 2024 18:18:54 -0500
Subject: [PATCH 1/3] Revert "[libc++] Add an ABI setting to harden
 unique_ptr<T[]>::operator[] (#91798)"

This reverts commit 45a09d1811d5d6597385ef02ecf2d4b7320c37c5.
---
 ...-hardening-mode-fast-with-abi-breaks.cmake |   2 +-
 libcxx/include/CMakeLists.txt                 |   1 -
 libcxx/include/__configuration/abi.h          |   7 -
 libcxx/include/__memory/array_cookie.h        |  55 ------
 libcxx/include/__memory/unique_ptr.h          | 128 +-------------
 libcxx/include/module.modulemap               |   1 -
 .../unord.map/abi.compile.pass.cpp            |   4 -
 .../unord.set/abi.compile.pass.cpp            |   4 -
 .../unique.ptr.class/incomplete.sh.cpp        |  93 ----------
 .../assert.subscript.pass.cpp                 | 166 ------------------
 .../unique.ptr.observers/get.pass.cpp         | 117 +++---------
 .../op_subscript.runtime.pass.cpp             | 124 +++----------
 libcxx/utils/libcxx/test/features.py          |   1 -
 13 files changed, 58 insertions(+), 645 deletions(-)
 delete mode 100644 libcxx/include/__memory/array_cookie.h
 delete mode 100644 libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/incomplete.sh.cpp
 delete mode 100644 libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/assert.subscript.pass.cpp

diff --git a/libcxx/cmake/caches/Generic-hardening-mode-fast-with-abi-breaks.cmake b/libcxx/cmake/caches/Generic-hardening-mode-fast-with-abi-breaks.cmake
index f63436c7679478..c0f2bad1c95af0 100644
--- a/libcxx/cmake/caches/Generic-hardening-mode-fast-with-abi-breaks.cmake
+++ b/libcxx/cmake/caches/Generic-hardening-mode-fast-with-abi-breaks.cmake
@@ -1,2 +1,2 @@
 set(LIBCXX_HARDENING_MODE "fast" CACHE STRING "")
-set(LIBCXX_ABI_DEFINES "_LIBCPP_ABI_BOUNDED_ITERATORS;_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STRING;_LIBCPP_ABI_BOUNDED_ITERATORS_IN_VECTOR;_LIBCPP_ABI_BOUNDED_UNIQUE_PTR" CACHE STRING "")
+set(LIBCXX_ABI_DEFINES "_LIBCPP_ABI_BOUNDED_ITERATORS;_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STRING;_LIBCPP_ABI_BOUNDED_ITERATORS_IN_VECTOR" CACHE STRING "")
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 8a63280053340f..bbd5057cff9376 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -536,7 +536,6 @@ set(files
   __memory/allocator_arg_t.h
   __memory/allocator_destructor.h
   __memory/allocator_traits.h
-  __memory/array_cookie.h
   __memory/assume_aligned.h
   __memory/auto_ptr.h
   __memory/builtin_new_allocator.h
diff --git a/libcxx/include/__configuration/abi.h b/libcxx/include/__configuration/abi.h
index 62c129f5921dee..707e10b5ceb53f 100644
--- a/libcxx/include/__configuration/abi.h
+++ b/libcxx/include/__configuration/abi.h
@@ -181,13 +181,6 @@
 #  define _LIBCPP_ABI_NO_COMPRESSED_PAIR_PADDING
 #endif
 
-// Tracks the bounds of the array owned by std::unique_ptr<T[]>, allowing it to trap when accessed out-of-bounds.
-// Note that limited bounds checking is also available outside of this ABI configuration, but only some categories
-// of types can be checked.
-//
-// ABI impact: This causes the layout of std::unique_ptr<T[]> to change and its size to increase.
-// #define _LIBCPP_ABI_BOUNDED_UNIQUE_PTR
-
 #if defined(_LIBCPP_COMPILER_CLANG_BASED)
 #  if defined(__APPLE__)
 #    if defined(__i386__) || defined(__x86_64__)
diff --git a/libcxx/include/__memory/array_cookie.h b/libcxx/include/__memory/array_cookie.h
deleted file mode 100644
index 34eec643206103..00000000000000
--- a/libcxx/include/__memory/array_cookie.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// -*- 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_ARRAY_COOKIE_H
-#define _LIBCPP___MEMORY_ARRAY_COOKIE_H
-
-#include <__config>
-#include <__configuration/abi.h>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_trivially_destructible.h>
-#include <__type_traits/negation.h>
-#include <cstddef>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// Trait representing whether a type requires an array cookie at the start of its allocation when
-// allocated as `new T[n]` and deallocated as `delete array`.
-//
-// Under the Itanium C++ ABI [1], we know that an array cookie is available unless `T` is trivially
-// destructible and the call to `operator delete[]` is not a sized operator delete. Under ABIs other
-// than the Itanium ABI, we assume there are no array cookies.
-//
-// [1]: https://itanium-cxx-abi.github.io/cxx-abi/abi.html#array-cookies
-#ifdef _LIBCPP_ABI_ITANIUM
-// TODO: Use a builtin instead
-// TODO: We should factor in the choice of the usual deallocation function in this determination.
-template <class _Tp>
-struct __has_array_cookie : _Not<is_trivially_destructible<_Tp> > {};
-#else
-template <class _Tp>
-struct __has_array_cookie : false_type {};
-#endif
-
-template <class _Tp>
-// Avoid failures when -fsanitize-address-poison-custom-array-cookie is enabled
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") size_t __get_array_cookie(_Tp const* __ptr) {
-  static_assert(
-      __has_array_cookie<_Tp>::value, "Trying to access the array cookie of a type that is not guaranteed to have one");
-  size_t const* __cookie = reinterpret_cast<size_t const*>(__ptr) - 1; // TODO: Use a builtin instead
-  return *__cookie;
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___MEMORY_ARRAY_COOKIE_H
diff --git a/libcxx/include/__memory/unique_ptr.h b/libcxx/include/__memory/unique_ptr.h
index 11215dc111e36a..9ca13d0e4fd1a7 100644
--- a/libcxx/include/__memory/unique_ptr.h
+++ b/libcxx/include/__memory/unique_ptr.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___MEMORY_UNIQUE_PTR_H
 #define _LIBCPP___MEMORY_UNIQUE_PTR_H
 
-#include <__assert>
 #include <__compare/compare_three_way.h>
 #include <__compare/compare_three_way_result.h>
 #include <__compare/three_way_comparable.h>
@@ -18,10 +17,8 @@
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <__memory/allocator_traits.h> // __pointer
-#include <__memory/array_cookie.h>
 #include <__memory/auto_ptr.h>
 #include <__memory/compressed_pair.h>
-#include <__memory/pointer_traits.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/conditional.h>
@@ -30,7 +27,6 @@
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_assignable.h>
-#include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_function.h>
@@ -45,9 +41,7 @@
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <__utility/private_constructor_tag.h>
 #include <cstddef>
-#include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -298,91 +292,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr {
   }
 };
 
-// Bounds checking in unique_ptr<T[]>
-// ==================================
-//
-// We provide some helper classes that allow bounds checking when accessing a unique_ptr<T[]>.
-// There are a few cases where bounds checking can be implemented:
-//
-// 1. When an array cookie (see [1]) exists at the beginning of the array allocation, we are
-//    able to reuse that cookie to extract the size of the array and perform bounds checking.
-//    An array cookie is a size inserted at the beginning of the allocation by the compiler.
-//    That size is inserted implicitly when doing `new T[n]` in some cases, and its purpose
-//    is to allow the runtime to destroy the `n` array elements when doing `delete array`.
-//    When we are able to use array cookies, we reuse information already available in the
-//    current runtime, so bounds checking does not require changing libc++'s ABI.
-//
-// 2. When the "bounded unique_ptr" ABI configuration (controlled by `_LIBCPP_ABI_BOUNDED_UNIQUE_PTR`)
-//    is enabled, we store the size of the allocation (when it is known) so we can check it when
-//    indexing into the `unique_ptr`. That changes the layout of `std::unique_ptr<T[]>`, which is
-//    an ABI break from the default configuration.
-//
-//    Note that even under this ABI configuration, we can't always know the size of the unique_ptr.
-//    Indeed, the size of the allocation can only be known when the unique_ptr is created via
-//    make_unique or a similar API. For example, it can't be known when constructed from an arbitrary
-//    pointer, in which case we are not able to check the bounds on access:
-//
-//      unique_ptr<T[], MyDeleter> ptr(new T[3]);
-//
-//    When we don't know the size of the allocation via the API used to create the unique_ptr, we
-//    try to fall back to using an array cookie when available.
-//
-//    Finally, note that when this ABI configuration is enabled, we have no choice but to always
-//    make space for a size to be stored in the unique_ptr. Indeed, while we might want to avoid
-//    storing the size when an array cookie is available, knowing whether an array cookie is available
-//    requires the type stored in the unique_ptr to be complete, while unique_ptr can normally
-//    accommodate incomplete types.
-//
-// (1) Implementation where we rely on the array cookie to know the size of the allocation, if
-//     an array cookie exists.
-struct __unique_ptr_array_bounds_stateless {
-  __unique_ptr_array_bounds_stateless() = default;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __unique_ptr_array_bounds_stateless(size_t) {}
-
-  template <class _Tp, __enable_if_t<__has_array_cookie<_Tp>::value, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __in_bounds(_Tp* __ptr, size_t __index) const {
-    // In constant expressions, we can't check the array cookie so we just pretend that the index
-    // is in-bounds. The compiler catches invalid accesses anyway.
-    if (__libcpp_is_constant_evaluated())
-      return true;
-    size_t __cookie = std::__get_array_cookie(__ptr);
-    return __index < __cookie;
-  }
-
-  template <class _Tp, __enable_if_t<!__has_array_cookie<_Tp>::value, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __in_bounds(_Tp*, size_t) const {
-    return true; // If we don't have an array cookie, we assume the access is in-bounds
-  }
-};
-
-// (2) Implementation where we store the size in the class whenever we have it.
-//
-// Semantically, we'd need to store the size as an optional<size_t>. However, since that
-// is really heavy weight, we instead store a size_t and use SIZE_MAX as a magic value
-// meaning that we don't know the size.
-struct __unique_ptr_array_bounds_stored {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __unique_ptr_array_bounds_stored() : __size_(SIZE_MAX) {}
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __unique_ptr_array_bounds_stored(size_t __size) : __size_(__size) {}
-
-  // Use the array cookie if there's one
-  template <class _Tp, __enable_if_t<__has_array_cookie<_Tp>::value, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __in_bounds(_Tp* __ptr, size_t __index) const {
-    if (__libcpp_is_constant_evaluated())
-      return true;
-    size_t __cookie = std::__get_array_cookie(__ptr);
-    return __index < __cookie;
-  }
-
-  // Otherwise, fall back on the stored size (if any)
-  template <class _Tp, __enable_if_t<!__has_array_cookie<_Tp>::value, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __in_bounds(_Tp*, size_t __index) const {
-    return __index < __size_;
-  }
-
-private:
-  size_t __size_;
-};
-
 template <class _Tp, class _Dp>
 class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> {
 public:
@@ -391,9 +300,8 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
   typedef typename __pointer<_Tp, deleter_type>::type pointer;
 
   // A unique_ptr contains the following members which may be trivially relocatable:
-  // - pointer: this may be trivially relocatable, so it's checked
+  // - pointer : this may be trivially relocatable, so it's checked
   // - deleter_type: this may be trivially relocatable, so it's checked
-  // - (optionally) size: this is trivially relocatable
   //
   // This unique_ptr implementation only contains a pointer to the unique object and a deleter, so there are no
   // references to itself. This means that the entire structure is trivially relocatable if its members are.
@@ -403,16 +311,7 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
       void>;
 
 private:
-  template <class _Up, class _OtherDeleter>
-  friend class unique_ptr;
-
   _LIBCPP_COMPRESSED_PAIR(pointer, __ptr_, deleter_type, __deleter_);
-#ifdef _LIBCPP_ABI_BOUNDED_UNIQUE_PTR
-  using _BoundsChecker = __unique_ptr_array_bounds_stored;
-#else
-  using _BoundsChecker = __unique_ptr_array_bounds_stateless;
-#endif
-  _LIBCPP_NO_UNIQUE_ADDRESS _BoundsChecker __checker_;
 
   template <class _From>
   struct _CheckArrayPointerConversion : is_same<_From, pointer> {};
@@ -474,12 +373,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
       : __ptr_(__p),
         __deleter_() {}
 
-  // Private constructor used by make_unique & friends to pass the size that was allocated
-  template <class _Tag, class _Ptr, __enable_if_t<is_same<_Tag, __private_constructor_tag>::value, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit unique_ptr(_Tag, _Ptr __ptr, size_t __size) _NOEXCEPT
-      : __ptr_(__ptr),
-        __checker_(__size) {}
-
   template <class _Pp,
             bool _Dummy = true,
             class       = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
@@ -518,13 +411,11 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr&& __u) _NOEXCEPT
       : __ptr_(__u.release()),
-        __deleter_(std::forward<deleter_type>(__u.get_deleter())),
-        __checker_(std::move(__u.__checker_)) {}
+        __deleter_(std::forward<deleter_type>(__u.get_deleter())) {}
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
     __deleter_ = std::forward<deleter_type>(__u.get_deleter());
-    __checker_ = std::move(std::move(__u.__checker_));
     return *this;
   }
 
@@ -534,8 +425,7 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
             class = _EnableIfDeleterConvertible<_Ep> >
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
       : __ptr_(__u.release()),
-        __deleter_(std::forward<_Ep>(__u.get_deleter())),
-        __checker_(std::move(__u.__checker_)) {}
+        __deleter_(std::forward<_Ep>(__u.get_deleter())) {}
 
   template <class _Up,
             class _Ep,
@@ -544,7 +434,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __deleter_ = std::forward<_Ep>(__u.get_deleter());
-    __checker_ = std::move(__u.__checker_);
     return *this;
   }
 
@@ -562,8 +451,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __add_lvalue_reference_t<_Tp> operator[](size_t __i) const {
-    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__checker_.__in_bounds(std::__to_address(__ptr_), __i),
-                                        "unique_ptr<T[]>::operator[](index): index out of range");
     return __ptr_[__i];
   }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_; }
@@ -580,8 +467,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
     pointer __t = __ptr_;
     __ptr_      = pointer();
-    // The deleter and the optional bounds-checker are left unchanged. The bounds-checker
-    // will be reinitialized appropriately when/if the unique_ptr gets assigned-to or reset.
     return __t;
   }
 
@@ -589,7 +474,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(_Pp __p) _NOEXCEPT {
     pointer __tmp = __ptr_;
     __ptr_        = __p;
-    __checker_    = _BoundsChecker();
     if (__tmp)
       __deleter_(__tmp);
   }
@@ -597,7 +481,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(nullptr_t = nullptr) _NOEXCEPT {
     pointer __tmp = __ptr_;
     __ptr_        = nullptr;
-    __checker_    = _BoundsChecker();
     if (__tmp)
       __deleter_(__tmp);
   }
@@ -606,7 +489,6 @@ class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp>
     using std::swap;
     swap(__ptr_, __u.__ptr_);
     swap(__deleter_, __u.__deleter_);
-    swap(__checker_, __u.__checker_);
   }
 };
 
@@ -763,7 +645,7 @@ template <class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_array_unknown_bound
 make_unique(size_t __n) {
   typedef __remove_extent_t<_Tp> _Up;
-  return unique_ptr<_Tp>(__private_constructor_tag(), new _Up[__n](), __n);
+  return unique_ptr<_Tp>(new _Up[__n]());
 }
 
 template <class _Tp, class... _Args>
@@ -782,7 +664,7 @@ make_unique_for_overwrite() {
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_array_unknown_bound
 make_unique_for_overwrite(size_t __n) {
-  return unique_ptr<_Tp>(__private_constructor_tag(), new __remove_extent_t<_Tp>[__n], __n);
+  return unique_ptr<_Tp>(new __remove_extent_t<_Tp>[__n]);
 }
 
 template <class _Tp, class... _Args>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index aa05bde939f6c2..97330aa6ad2813 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -1485,7 +1485,6 @@ module std [system] {
     module allocator_destructor               { header "__memory/allocator_destructor.h" }
     module allocator_traits                   { header "__memory/allocator_traits.h" }
     module assume_aligned                     { header "__memory/assume_aligned.h" }
-    module array_cookie                       { header "__memory/array_cookie.h" }
     module auto_ptr                           { header "__memory/auto_ptr.h" }
     module builtin_new_allocator              { header "__memory/builtin_new_allocator.h" }
     module compressed_pair                    { header "__memory/compressed_pair.h" }
diff --git a/libcxx/test/libcxx/containers/associative/unord.map/abi.compile.pass.cpp b/libcxx/test/libcxx/containers/associative/unord.map/abi.compile.pass.cpp
index cea074a4e70f1f..9147ca93866b23 100644
--- a/libcxx/test/libcxx/containers/associative/unord.map/abi.compile.pass.cpp
+++ b/libcxx/test/libcxx/containers/associative/unord.map/abi.compile.pass.cpp
@@ -8,10 +8,6 @@
 
 // UNSUPPORTED: libcpp-has-abi-fix-unordered-container-size-type, libcpp-abi-no-compressed-pair-padding
 
-// std::unique_ptr is used as an implementation detail of the unordered containers, so the layout of
-// unordered containers changes when bounded unique_ptr is enabled.
-// UNSUPPORTED: libcpp-has-abi-bounded-unique_ptr
-
 #include <cstdint>
 #include <unordered_map>
 
diff --git a/libcxx/test/libcxx/containers/associative/unord.set/abi.compile.pass.cpp b/libcxx/test/libcxx/containers/associative/unord.set/abi.compile.pass.cpp
index 2a112aff227d8e..dc6cc082c3b99e 100644
--- a/libcxx/test/libcxx/containers/associative/unord.set/abi.compile.pass.cpp
+++ b/libcxx/test/libcxx/containers/associative/unord.set/abi.compile.pass.cpp
@@ -8,10 +8,6 @@
 
 // UNSUPPORTED: libcpp-has-abi-fix-unordered-container-size-type, libcpp-abi-no-compressed-pair-padding
 
-// std::unique_ptr is used as an implementation detail of the unordered containers, so the layout of
-// unordered containers changes when bounded unique_ptr is enabled.
-// UNSUPPORTED: libcpp-has-abi-bounded-unique_ptr
-
 #include <cstdint>
 #include <unordered_set>
 
diff --git a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/incomplete.sh.cpp b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/incomplete.sh.cpp
deleted file mode 100644
index 4a03d2bcf07bfe..00000000000000
--- a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/incomplete.sh.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <memory>
-
-// unique_ptr
-
-// Make sure that we can form unique_ptrs to incomplete types and perform restricted
-// operations on them. This requires setting up a TU where the type is complete and
-// the unique_ptr is created and destroyed, and a TU where the type is incomplete and
-// we check that a restricted set of operations can be performed on the unique_ptr.
-
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.tu1.o -DCOMPLETE
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.tu2.o -DINCOMPLETE
-// RUN: %{cxx} %t.tu1.o %t.tu2.o %{flags} %{link_flags} -o %t.exe
-// RUN: %{exec} %t.exe
-
-#include <memory>
-#include <cassert>
-
-struct T;
-extern void use(std::unique_ptr<T>& ptr);
-extern void use(std::unique_ptr<T[]>& ptr);
-
-#ifdef INCOMPLETE
-
-void use(std::unique_ptr<T>& ptr) {
-  {
-    T* x = ptr.get();
-    assert(x != nullptr);
-  }
-  {
-    T& ref = *ptr;
-    assert(&ref == ptr.get());
-  }
-  {
-    bool engaged = static_cast<bool>(ptr);
-    assert(engaged);
-  }
-  {
-    assert(ptr == ptr);
-    assert(!(ptr != ptr));
-    assert(!(ptr < ptr));
-    assert(!(ptr > ptr));
-    assert(ptr <= ptr);
-    assert(ptr >= ptr);
-  }
-}
-
-void use(std::unique_ptr<T[]>& ptr) {
-  {
-    T* x = ptr.get();
-    assert(x != nullptr);
-  }
-  {
-    bool engaged = static_cast<bool>(ptr);
-    assert(engaged);
-  }
-  {
-    assert(ptr == ptr);
-    assert(!(ptr != ptr));
-    assert(!(ptr < ptr));
-    assert(!(ptr > ptr));
-    assert(ptr <= ptr);
-    assert(ptr >= ptr);
-  }
-}
-
-#endif // INCOMPLETE
-
-#ifdef COMPLETE
-
-struct T {}; // complete the type
-
-int main(int, char**) {
-  {
-    std::unique_ptr<T> ptr(new T());
-    use(ptr);
-  }
-
-  {
-    std::unique_ptr<T[]> ptr(new T[3]());
-    use(ptr);
-  }
-  return 0;
-}
-
-#endif // COMPLETE
diff --git a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/assert.subscript.pass.cpp b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/assert.subscript.pass.cpp
deleted file mode 100644
index 1eaf2d5900356b..00000000000000
--- a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/assert.subscript.pass.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// REQUIRES: has-unix-headers
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-hardening-mode=none
-// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing
-
-// <memory>
-//
-// unique_ptr<T[]>
-//
-// T& operator[](std::size_t);
-
-// This test ensures that we catch an out-of-bounds access in std::unique_ptr<T[]>::operator[]
-// when unique_ptr has the appropriate ABI configuration.
-
-#include <memory>
-#include <cstddef>
-#include <string>
-
-#include "check_assertion.h"
-#include "type_algorithms.h"
-
-struct MyDeleter {
-  MyDeleter() = default;
-
-  // required to exercise converting move-constructor
-  template <class T>
-  MyDeleter(std::default_delete<T> const&) {}
-
-  // required to exercise converting move-assignment
-  template <class T>
-  MyDeleter& operator=(std::default_delete<T> const&) {
-    return *this;
-  }
-
-  template <class T>
-  void operator()(T* ptr) const {
-    delete[] ptr;
-  }
-};
-
-template <class WithCookie, class NoCookie>
-void test() {
-  // For types with an array cookie, we can always detect OOB accesses.
-  {
-    // Check with the default deleter
-    {
-      {
-        std::unique_ptr<WithCookie[]> ptr(new WithCookie[5]);
-        TEST_LIBCPP_ASSERT_FAILURE(ptr[6], "unique_ptr<T[]>::operator[](index): index out of range");
-      }
-      {
-        std::unique_ptr<WithCookie[]> ptr = std::make_unique<WithCookie[]>(5);
-        TEST_LIBCPP_ASSERT_FAILURE(ptr[6], "unique_ptr<T[]>::operator[](index): index out of range");
-      }
-#if TEST_STD_VER >= 20
-      {
-        std::unique_ptr<WithCookie[]> ptr = std::make_unique_for_overwrite<WithCookie[]>(5);
-        TEST_LIBCPP_ASSERT_FAILURE(ptr[6] = WithCookie(), "unique_ptr<T[]>::operator[](index): index out of range");
-      }
-#endif
-    }
-
-    // Check with a custom deleter
-    {
-      std::unique_ptr<WithCookie[], MyDeleter> ptr(new WithCookie[5]);
-      TEST_LIBCPP_ASSERT_FAILURE(ptr[6], "unique_ptr<T[]>::operator[](index): index out of range");
-    }
-  }
-
-  // For types that don't have an array cookie, things are a bit more complicated. We can detect OOB accesses
-  // only when the unique_ptr is created via an API where the size is passed down to the library so that we
-  // can store it inside the unique_ptr. That requires the appropriate ABI configuration to be enabled.
-  //
-  // Note that APIs that allow the size to be passed down to the library only support the default deleter
-  // as of writing this test.
-#if defined(_LIBCPP_ABI_BOUNDED_UNIQUE_PTR)
-  {
-    {
-      std::unique_ptr<NoCookie[]> ptr = std::make_unique<NoCookie[]>(5);
-      TEST_LIBCPP_ASSERT_FAILURE(ptr[6], "unique_ptr<T[]>::operator[](index): index out of range");
-    }
-#  if TEST_STD_VER >= 20
-    {
-      std::unique_ptr<NoCookie[]> ptr = std::make_unique_for_overwrite<NoCookie[]>(5);
-      TEST_LIBCPP_ASSERT_FAILURE(ptr[6] = NoCookie(), "unique_ptr<T[]>::operator[](index): index out of range");
-    }
-#  endif
-  }
-#endif
-
-  // Make sure that we carry the bounds information properly through conversions, assignments, etc.
-  // These tests are mostly relevant when the ABI setting is enabled (with a stateful bounds-checker),
-  // but we still run them for types with an array cookie either way.
-#if defined(_LIBCPP_ABI_BOUNDED_UNIQUE_PTR)
-  using Types = types::type_list<NoCookie, WithCookie>;
-#else
-  using Types = types::type_list<WithCookie>;
-#endif
-  types::for_each(Types(), []<class T> {
-    // Bounds carried through move construction
-    {
-      std::unique_ptr<T[]> ptr = std::make_unique<T[]>(5);
-      std::unique_ptr<T[]> other(std::move(ptr));
-      TEST_LIBCPP_ASSERT_FAILURE(other[6], "unique_ptr<T[]>::operator[](index): index out of range");
-    }
-
-    // Bounds carried through move assignment
-    {
-      std::unique_ptr<T[]> ptr = std::make_unique<T[]>(5);
-      std::unique_ptr<T[]> other;
-      other = std::move(ptr);
-      TEST_LIBCPP_ASSERT_FAILURE(other[6], "unique_ptr<T[]>::operator[](index): index out of range");
-    }
-
-    // Bounds carried through converting move-constructor
-    {
-      std::unique_ptr<T[]> ptr = std::make_unique<T[]>(5);
-      std::unique_ptr<T[], MyDeleter> other(std::move(ptr));
-      TEST_LIBCPP_ASSERT_FAILURE(other[6], "unique_ptr<T[]>::operator[](index): index out of range");
-    }
-
-    // Bounds carried through converting move-assignment
-    {
-      std::unique_ptr<T[]> ptr = std::make_unique<T[]>(5);
-      std::unique_ptr<T[], MyDeleter> other;
-      other = std::move(ptr);
-      TEST_LIBCPP_ASSERT_FAILURE(other[6], "unique_ptr<T[]>::operator[](index): index out of range");
-    }
-  });
-}
-
-template <std::size_t Size>
-struct NoCookie {
-  char padding[Size];
-};
-
-template <std::size_t Size>
-struct WithCookie {
-  WithCookie() = default;
-  WithCookie(WithCookie const&) {}
-  WithCookie& operator=(WithCookie const&) { return *this; }
-  ~WithCookie() {}
-  char padding[Size];
-};
-
-int main(int, char**) {
-  test<WithCookie<1>, NoCookie<1>>();
-  test<WithCookie<2>, NoCookie<2>>();
-  test<WithCookie<3>, NoCookie<3>>();
-  test<WithCookie<4>, NoCookie<4>>();
-  test<WithCookie<8>, NoCookie<8>>();
-  test<WithCookie<16>, NoCookie<16>>();
-  test<WithCookie<32>, NoCookie<32>>();
-  test<WithCookie<256>, NoCookie<256>>();
-  test<std::string, int>();
-
-  return 0;
-}
diff --git a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
index c92c39c8f299e9..3bd3788960e2a6 100644
--- a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
+++ b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/get.pass.cpp
@@ -10,114 +10,43 @@
 
 // unique_ptr
 
-// pointer unique_ptr<T>::get() const noexcept;
-// pointer unique_ptr<T[]>::get() const noexcept;
+// test get
 
 #include <memory>
 #include <cassert>
-#include <cstddef>
 
 #include "test_macros.h"
+#include "unique_ptr_test_helper.h"
 
-template <class T>
+template <bool IsArray>
 TEST_CONSTEXPR_CXX23 void test_basic() {
-  // non-const element type
+  typedef typename std::conditional<IsArray, int[], int>::type VT;
+  typedef const VT CVT;
   {
-    // non-const access
-    {
-      T* x = new T;
-      std::unique_ptr<T> ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T*);
-      ASSERT_NOEXCEPT(ptr.get());
-      assert(ptr.get() == x);
-    }
-
-    // const access
-    {
-      T* x = new T;
-      std::unique_ptr<T> const ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T*);
-      ASSERT_NOEXCEPT(ptr.get());
-      assert(ptr.get() == x);
-    }
-  }
-
-  // const element type
-  {
-    // non-const access
-    {
-      T* x = new T;
-      std::unique_ptr<T const> ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T const*);
-      assert(ptr.get() == x);
-    }
-
-    // const access
-    {
-      T* x = new T;
-      std::unique_ptr<T const> const ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T const*);
-      assert(ptr.get() == x);
-    }
-  }
-
-  // Same thing but for unique_ptr<T[]>
-  // non-const element type
-  {
-    // non-const access
-    {
-      T* x = new T[3];
-      std::unique_ptr<T[]> ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T*);
-      ASSERT_NOEXCEPT(ptr.get());
-      assert(ptr.get() == x);
-    }
-
-    // const access
-    {
-      T* x = new T[3];
-      std::unique_ptr<T[]> const ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T*);
-      ASSERT_NOEXCEPT(ptr.get());
-      assert(ptr.get() == x);
-    }
+    typedef std::unique_ptr<VT> U;
+    int* p = newValue<VT>(1);
+    U s(p);
+    U const& sc = s;
+    ASSERT_SAME_TYPE(decltype(s.get()), int*);
+    ASSERT_SAME_TYPE(decltype(sc.get()), int*);
+    assert(s.get() == p);
+    assert(sc.get() == s.get());
   }
-
-  // const element type
   {
-    // non-const access
-    {
-      T* x = new T[3];
-      std::unique_ptr<T const[]> ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T const*);
-      assert(ptr.get() == x);
-    }
-
-    // const access
-    {
-      T* x = new T[3];
-      std::unique_ptr<T const[]> const ptr(x);
-      ASSERT_SAME_TYPE(decltype(ptr.get()), T const*);
-      assert(ptr.get() == x);
-    }
+    typedef std::unique_ptr<CVT> U;
+    const int* p = newValue<VT>(1);
+    U s(p);
+    U const& sc = s;
+    ASSERT_SAME_TYPE(decltype(s.get()), const int*);
+    ASSERT_SAME_TYPE(decltype(sc.get()), const int*);
+    assert(s.get() == p);
+    assert(sc.get() == s.get());
   }
 }
 
-template <std::size_t Size>
-struct WithSize {
-  char padding[Size];
-};
-
 TEST_CONSTEXPR_CXX23 bool test() {
-  test_basic<char>();
-  test_basic<int>();
-  test_basic<WithSize<1> >();
-  test_basic<WithSize<2> >();
-  test_basic<WithSize<3> >();
-  test_basic<WithSize<4> >();
-  test_basic<WithSize<8> >();
-  test_basic<WithSize<16> >();
-  test_basic<WithSize<256> >();
+  test_basic</*IsArray*/ false>();
+  test_basic<true>();
 
   return true;
 }
diff --git a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
index ebfad8ec724e51..fbb4dbc6e03088 100644
--- a/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
+++ b/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/op_subscript.runtime.pass.cpp
@@ -10,117 +10,51 @@
 
 // unique_ptr
 
-// T& unique_ptr::operator[](size_t) const
+// test op[](size_t)
 
 #include <memory>
 #include <cassert>
+
+// TODO: Move TEST_IS_CONSTANT_EVALUATED into its own header
 #include <type_traits>
-#include <array>
 
 #include "test_macros.h"
-#include "type_algorithms.h"
 
-static int next = 0;
-struct EnumeratedDefaultCtor {
-  EnumeratedDefaultCtor() : value(0) { value = ++next; }
-  int value;
-};
+class A {
+  int state_;
+  static int next_;
 
-template <std::size_t Size>
-struct WithTrivialDtor {
-  std::array<char, Size> padding = {'x'};
-  TEST_CONSTEXPR_CXX23 friend bool operator==(WithTrivialDtor const& x, WithTrivialDtor const& y) {
-    return x.padding == y.padding;
+public:
+  TEST_CONSTEXPR_CXX23 A() : state_(0) {
+    if (!TEST_IS_CONSTANT_EVALUATED)
+      state_ = ++next_;
   }
-};
 
-template <std::size_t Size>
-struct WithNonTrivialDtor {
-  std::array<char, Size> padding = {'x'};
-  TEST_CONSTEXPR_CXX23 friend bool operator==(WithNonTrivialDtor const& x, WithNonTrivialDtor const& y) {
-    return x.padding == y.padding;
-  }
-  TEST_CONSTEXPR_CXX23 ~WithNonTrivialDtor() {}
-};
+  TEST_CONSTEXPR_CXX23 int get() const { return state_; }
 
-template <class T>
-struct CustomDeleter : std::default_delete<T> {};
+  friend TEST_CONSTEXPR_CXX23 bool operator==(const A& x, int y) { return x.state_ == y; }
 
-TEST_CONSTEXPR_CXX23 bool test() {
-  // Basic test
-  {
-    std::unique_ptr<int[]> p(new int[3]);
-    {
-      int& result = p[0];
-      result      = 0;
-    }
-    {
-      int& result = p[1];
-      result      = 1;
-    }
-    {
-      int& result = p[2];
-      result      = 2;
-    }
-
-    assert(p[0] == 0);
-    assert(p[1] == 1);
-    assert(p[2] == 2);
+  TEST_CONSTEXPR_CXX23 A& operator=(int i) {
+    state_ = i;
+    return *this;
   }
+};
 
-  // Ensure that the order of access is correct after initializing a unique_ptr but
-  // before actually modifying any of its elements. The implementation would have to
-  // really try for this not to be the case, but we still check it.
-  //
-  // This requires assigning known values to the elements when they are first constructed,
-  // which requires global state.
-  {
-    if (!TEST_IS_CONSTANT_EVALUATED) {
-      std::unique_ptr<EnumeratedDefaultCtor[]> p(new EnumeratedDefaultCtor[3]);
-      assert(p[0].value == 1);
-      assert(p[1].value == 2);
-      assert(p[2].value == 3);
-    }
-  }
+int A::next_ = 0;
 
-  // Make sure operator[] is const-qualified
-  {
-    std::unique_ptr<int[]> const p(new int[3]);
-    p[0] = 42;
-    assert(p[0] == 42);
-  }
-
-  // Make sure we properly handle types with trivial and non-trivial destructors of different
-  // sizes. This is relevant because some implementations may want to use properties of the
-  // ABI like array cookies and these properties often depend on e.g. the triviality of T's
-  // destructor, T's size and so on.
-#if TEST_STD_VER >= 20 // this test is too painful to write before C++20
-  {
-    using TrickyCookieTypes = types::type_list<
-        WithTrivialDtor<1>,
-        WithTrivialDtor<2>,
-        WithTrivialDtor<3>,
-        WithTrivialDtor<4>,
-        WithTrivialDtor<8>,
-        WithTrivialDtor<16>,
-        WithTrivialDtor<256>,
-        WithNonTrivialDtor<1>,
-        WithNonTrivialDtor<2>,
-        WithNonTrivialDtor<3>,
-        WithNonTrivialDtor<4>,
-        WithNonTrivialDtor<8>,
-        WithNonTrivialDtor<16>,
-        WithNonTrivialDtor<256>>;
-    types::for_each(TrickyCookieTypes(), []<class T> {
-      types::for_each(types::type_list<std::default_delete<T[]>, CustomDeleter<T[]>>(), []<class Deleter> {
-        std::unique_ptr<T[], Deleter> p(new T[3]);
-        assert(p[0] == T());
-        assert(p[1] == T());
-        assert(p[2] == T());
-      });
-    });
+TEST_CONSTEXPR_CXX23 bool test() {
+  std::unique_ptr<A[]> p(new A[3]);
+  if (!TEST_IS_CONSTANT_EVALUATED) {
+    assert(p[0] == 1);
+    assert(p[1] == 2);
+    assert(p[2] == 3);
   }
-#endif // C++20
+  p[0] = 3;
+  p[1] = 2;
+  p[2] = 1;
+  assert(p[0] == 3);
+  assert(p[1] == 2);
+  assert(p[2] == 1);
 
   return true;
 }
diff --git a/libcxx/utils/libcxx/test/features.py b/libcxx/utils/libcxx/test/features.py
index 29810c8ffee537..9ee5f645b4d910 100644
--- a/libcxx/utils/libcxx/test/features.py
+++ b/libcxx/utils/libcxx/test/features.py
@@ -374,7 +374,6 @@ def _mingwSupportsModules(cfg):
     "_LIBCPP_ABI_BOUNDED_ITERATORS": "libcpp-has-abi-bounded-iterators",
     "_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STRING": "libcpp-has-abi-bounded-iterators-in-string",
     "_LIBCPP_ABI_BOUNDED_ITERATORS_IN_VECTOR": "libcpp-has-abi-bounded-iterators-in-vector",
-    "_LIBCPP_ABI_BOUNDED_UNIQUE_PTR": "libcpp-has-abi-bounded-unique_ptr",
     "_LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE": "libcpp-has-abi-fix-unordered-container-size-type",
     "_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR": "libcpp-deprecated-abi-disable-pair-trivial-copy-ctor",
     "_LIBCPP_ABI_NO_COMPRESSED_PAIR_PADDING": "libcpp-abi-no-compressed-pair-padding",

>From 9a62bb5d6691e51b802818994e0e39a28e6591de Mon Sep 17 00:00:00 2001
From: Chris Bieneman <chris.bieneman at me.com>
Date: Sat, 28 Sep 2024 18:19:06 -0500
Subject: [PATCH 2/3] Revert "[libc++][NFC] Rename fold.h to ranges_fold.h
 (#109696)"

This reverts commit 24bc3244d4e221f4e6740f45e2bf15a1441a3076.
---
 libcxx/include/CMakeLists.txt                        | 2 +-
 libcxx/include/__algorithm/{ranges_fold.h => fold.h} | 6 +++---
 libcxx/include/algorithm                             | 2 +-
 libcxx/include/module.modulemap                      | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)
 rename libcxx/include/__algorithm/{ranges_fold.h => fold.h} (97%)

diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index bbd5057cff9376..c22590b0ddfdb5 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -23,6 +23,7 @@ set(files
   __algorithm/find_if.h
   __algorithm/find_if_not.h
   __algorithm/find_segment_if.h
+  __algorithm/fold.h
   __algorithm/for_each.h
   __algorithm/for_each_n.h
   __algorithm/for_each_segment.h
@@ -97,7 +98,6 @@ set(files
   __algorithm/ranges_find_if.h
   __algorithm/ranges_find_if_not.h
   __algorithm/ranges_find_last.h
-  __algorithm/ranges_fold.h
   __algorithm/ranges_for_each.h
   __algorithm/ranges_for_each_n.h
   __algorithm/ranges_generate.h
diff --git a/libcxx/include/__algorithm/ranges_fold.h b/libcxx/include/__algorithm/fold.h
similarity index 97%
rename from libcxx/include/__algorithm/ranges_fold.h
rename to libcxx/include/__algorithm/fold.h
index d2c39213985044..1bcb3be9aadabe 100644
--- a/libcxx/include/__algorithm/ranges_fold.h
+++ b/libcxx/include/__algorithm/fold.h
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP___ALGORITHM_RANGES_FOLD_H
-#define _LIBCPP___ALGORITHM_RANGES_FOLD_H
+#ifndef _LIBCPP___ALGORITHM_FOLD_H
+#define _LIBCPP___ALGORITHM_FOLD_H
 
 #include <__concepts/assignable.h>
 #include <__concepts/constructible.h>
@@ -126,4 +126,4 @@ _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP___ALGORITHM_RANGES_FOLD_H
+#endif // _LIBCPP___ALGORITHM_FOLD_H
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 17d63ce0cf1c0f..36fd035b7e51b3 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -2020,10 +2020,10 @@ template <class BidirectionalIterator, class Compare>
 #endif
 
 #if _LIBCPP_STD_VER >= 23
+#  include <__algorithm/fold.h>
 #  include <__algorithm/ranges_contains_subrange.h>
 #  include <__algorithm/ranges_ends_with.h>
 #  include <__algorithm/ranges_find_last.h>
-#  include <__algorithm/ranges_fold.h>
 #  include <__algorithm/ranges_starts_with.h>
 #endif // _LIBCPP_STD_VER >= 23
 
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 97330aa6ad2813..0c5569e6bd9af1 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -412,6 +412,7 @@ module std [system] {
     module find_if                                { header "__algorithm/find_if.h" }
     module find_segment_if                        { header "__algorithm/find_segment_if.h" }
     module find                                   { header "__algorithm/find.h" }
+    module fold                                   { header "__algorithm/fold.h" }
     module for_each_n                             { header "__algorithm/for_each_n.h" }
     module for_each_segment                       { header "__algorithm/for_each_segment.h" }
     module for_each                               { header "__algorithm/for_each.h" }
@@ -528,7 +529,6 @@ module std [system] {
     module ranges_find_if                         { header "__algorithm/ranges_find_if.h" }
     module ranges_find_last                       { header "__algorithm/ranges_find_last.h" }
     module ranges_find                            { header "__algorithm/ranges_find.h" }
-    module ranges_fold                            { header "__algorithm/ranges_fold.h" }
     module ranges_for_each_n {
       header "__algorithm/ranges_for_each_n.h"
       export std.algorithm.in_fun_result

>From 1cc92ee8a22fc8dd11e382c78b3a8a582f787573 Mon Sep 17 00:00:00 2001
From: Chris Bieneman <chris.bieneman at me.com>
Date: Sat, 28 Sep 2024 18:19:13 -0500
Subject: [PATCH 3/3] Revert "[libc++][modules] Rewrite the modulemap to have
 fewer top-level modules (#107638)"

This reverts commit bc6bd3bc1e99c7ec9e22dff23b4f4373fa02cae3.
---
 libcxx/include/CMakeLists.txt                 |    1 +
 libcxx/include/__format/formatter_integral.h  |    1 -
 libcxx/include/__std_clang_module             |  193 +
 libcxx/include/module.modulemap               | 4236 ++++++++---------
 .../test/libcxx/clang_modules_include.gen.py  |   14 +-
 .../utility/utility.synop/includes.pass.cpp   |   23 +
 libcxx/utils/CMakeLists.txt                   |    5 +
 .../utils/generate_std_clang_module_header.py |   63 +
 8 files changed, 2351 insertions(+), 2185 deletions(-)
 create mode 100644 libcxx/include/__std_clang_module
 create mode 100644 libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
 create mode 100644 libcxx/utils/generate_std_clang_module_header.py

diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index c22590b0ddfdb5..8c61009167ddce 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -687,6 +687,7 @@ set(files
   __ranges/views.h
   __ranges/zip_view.h
   __split_buffer
+  __std_clang_module
   __std_mbstate_t.h
   __stop_token/atomic_unique_lock.h
   __stop_token/intrusive_list_view.h
diff --git a/libcxx/include/__format/formatter_integral.h b/libcxx/include/__format/formatter_integral.h
index 0c04cce855a08c..beed3ab8d93df1 100644
--- a/libcxx/include/__format/formatter_integral.h
+++ b/libcxx/include/__format/formatter_integral.h
@@ -27,7 +27,6 @@
 #include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>
 #include <array>
-#include <cstdint>
 #include <limits>
 #include <string>
 #include <string_view>
diff --git a/libcxx/include/__std_clang_module b/libcxx/include/__std_clang_module
new file mode 100644
index 00000000000000..a21ed26addfe8e
--- /dev/null
+++ b/libcxx/include/__std_clang_module
@@ -0,0 +1,193 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// WARNING, this entire header is generated by
+// utils/generate_std_clang_module_header.py
+// DO NOT MODIFY!
+
+// This header should not be directly included, it's exclusively to import all
+// of the libc++ public clang modules for the `std` clang module to export. In
+// other words, it's to facilitate `@import std;` in Objective-C++ and `import std`
+// in Swift to expose all of the libc++ interfaces. This is generally not
+// recommended, however there are some clients that need to import all of libc++
+// without knowing what "all" is.
+#if !__building_module(std)
+#  error "Do not include this header directly, include individual headers instead"
+#endif
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#include <algorithm>
+#include <any>
+#include <array>
+#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
+#  include <atomic>
+#endif
+#include <barrier>
+#include <bit>
+#include <bitset>
+#include <cassert>
+#include <ccomplex>
+#include <cctype>
+#include <cerrno>
+#include <cfenv>
+#include <cfloat>
+#include <charconv>
+#include <chrono>
+#include <cinttypes>
+#include <ciso646>
+#include <climits>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <clocale>
+#endif
+#include <cmath>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <codecvt>
+#endif
+#include <compare>
+#include <complex.h>
+#include <complex>
+#include <concepts>
+#include <condition_variable>
+#include <coroutine>
+#include <csetjmp>
+#include <csignal>
+#include <cstdarg>
+#include <cstdbool>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctgmath>
+#include <ctime>
+#include <ctype.h>
+#include <cuchar>
+#include <cwchar>
+#include <cwctype>
+#include <deque>
+#include <errno.h>
+#include <exception>
+#include <execution>
+#include <expected>
+#include <experimental/iterator>
+#include <experimental/memory>
+#include <experimental/propagate_const>
+#include <experimental/simd>
+#include <experimental/type_traits>
+#include <experimental/utility>
+#include <fenv.h>
+#include <filesystem>
+#include <float.h>
+#include <format>
+#include <forward_list>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <fstream>
+#endif
+#include <functional>
+#include <future>
+#include <initializer_list>
+#include <inttypes.h>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <iomanip>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <ios>
+#endif
+#include <iosfwd>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <iostream>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <istream>
+#endif
+#include <iterator>
+#include <latch>
+#include <limits>
+#include <list>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <locale.h>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <locale>
+#endif
+#include <map>
+#include <math.h>
+#include <mdspan>
+#include <memory>
+#include <memory_resource>
+#include <mutex>
+#include <new>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <ostream>
+#endif
+#include <print>
+#include <queue>
+#include <random>
+#include <ranges>
+#include <ratio>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <regex>
+#endif
+#include <scoped_allocator>
+#include <semaphore>
+#include <set>
+#include <shared_mutex>
+#include <source_location>
+#include <span>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <sstream>
+#endif
+#include <stack>
+#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
+#  include <stdatomic.h>
+#endif
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdexcept>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stop_token>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <streambuf>
+#endif
+#include <string.h>
+#include <string>
+#include <string_view>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <strstream>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <syncstream>
+#endif
+#include <system_error>
+#include <tgmath.h>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <typeindex>
+#include <typeinfo>
+#include <uchar.h>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <valarray>
+#include <variant>
+#include <vector>
+#include <version>
+#include <wchar.h>
+#include <wctype.h>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 0c5569e6bd9af1..ef4a242cf8bf7f 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -1,2234 +1,2124 @@
-// This module contains headers related to the configuration of the library. These headers
-// are free of any dependency on the rest of libc++.
-module std_config [system] {
-  textual header "__config"
-  textual header "__configuration/abi.h"
-  textual header "__configuration/availability.h"
-  textual header "__configuration/compiler.h"
-  textual header "__configuration/language.h"
-  textual header "__configuration/platform.h"
-  textual header "version"
+// Main C++ standard library interfaces
+module std_algorithm [system] {
+  header "algorithm"
+  export *
 }
-
-module std_core [system] {
-  module cstddef {
-    module byte         { header "__cstddef/byte.h" }
-    module max_align_t  { header "__cstddef/max_align_t.h" }
-    module nullptr_t    { header "__cstddef/nullptr_t.h" }
-    module ptrdiff_t    { header "__cstddef/ptrdiff_t.h" }
-    module size_t       { header "__cstddef/size_t.h" }
-  }
-
-  module cstdint {
-    header "cstdint"
-    export *
-  }
-
-  module fwd {
-    module byte         { header "__fwd/byte.h" }
-    module functional   { header "__fwd/functional.h" }
-    module pair         { header "__fwd/pair.h" }
-    module tuple        { header "__fwd/tuple.h" }
-  }
-
-  module limits {
-    header "limits"
-    export *
-  }
-
-  module math {
-    module abs                              { header "__math/abs.h" }
-    module copysign                         { header "__math/copysign.h" }
-    module error_functions                  { header "__math/error_functions.h" }
-    module exponential_functions            { header "__math/exponential_functions.h" }
-    module fdim                             { header "__math/fdim.h" }
-    module fma                              { header "__math/fma.h" }
-    module gamma                            { header "__math/gamma.h" }
-    module hyperbolic_functions             { header "__math/hyperbolic_functions.h" }
-    module hypot                            { header "__math/hypot.h" }
-    module inverse_hyperbolic_functions     { header "__math/inverse_hyperbolic_functions.h" }
-    module inverse_trigonometric_functions  { header "__math/inverse_trigonometric_functions.h" }
-    module logarithms                       { header "__math/logarithms.h" }
-    module min_max                          { header "__math/min_max.h" }
-    module modulo                           { header "__math/modulo.h" }
-    module remainder                        { header "__math/remainder.h" }
-    module roots                            { header "__math/roots.h" }
-    module rounding_functions               { header "__math/rounding_functions.h" }
-    module special_functions                { header "__math/special_functions.h" }
-    module traits                           { header "__math/traits.h" }
-    module trigonometric_functions          { header "__math/trigonometric_functions.h" }
-  }
-
-  module type_traits {
-    module add_const                                  { header "__type_traits/add_const.h" }
-    module add_cv                                     { header "__type_traits/add_cv.h" }
-    module add_lvalue_reference                       { header "__type_traits/add_lvalue_reference.h" }
-    module add_pointer                                { header "__type_traits/add_pointer.h" }
-    module add_rvalue_reference                       { header "__type_traits/add_rvalue_reference.h" }
-    module add_volatile                               { header "__type_traits/add_volatile.h" }
-    module aligned_storage                            { header "__type_traits/aligned_storage.h" }
-    module aligned_union                              { header "__type_traits/aligned_union.h" }
-    module alignment_of                               { header "__type_traits/alignment_of.h" }
-    module can_extract_key                            { header "__type_traits/can_extract_key.h" }
-    module common_reference                           { header "__type_traits/common_reference.h" }
-    module common_type                                { header "__type_traits/common_type.h" }
-    module conditional                                { header "__type_traits/conditional.h" }
-    module conjunction                                { header "__type_traits/conjunction.h" }
-    module copy_cv                                    { header "__type_traits/copy_cv.h" }
-    module copy_cvref                                 { header "__type_traits/copy_cvref.h" }
-    module datasizeof                                 { header "__type_traits/datasizeof.h" }
-    module decay                                      { header "__type_traits/decay.h" }
-    module dependent_type                             { header "__type_traits/dependent_type.h" }
-    module desugars_to                                { header "__type_traits/desugars_to.h" }
-    module disjunction                                { header "__type_traits/disjunction.h" }
-    module enable_if                                  { header "__type_traits/enable_if.h" }
-    module extent                                     { header "__type_traits/extent.h" }
-    module has_unique_object_representation           { header "__type_traits/has_unique_object_representation.h" }
-    module has_virtual_destructor                     { header "__type_traits/has_virtual_destructor.h" }
-    module integral_constant                          { header "__type_traits/integral_constant.h" }
-    module invoke                                     { header "__type_traits/invoke.h" }
-    module is_abstract {
-      header "__type_traits/is_abstract.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_aggregate {
-      header "__type_traits/is_aggregate.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_allocator {
-      header "__type_traits/is_allocator.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_always_bitcastable {
-      header "__type_traits/is_always_bitcastable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_arithmetic {
-      header "__type_traits/is_arithmetic.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_array {
-      header "__type_traits/is_array.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_assignable {
-      header "__type_traits/is_assignable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_base_of {
-      header "__type_traits/is_base_of.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_bounded_array {
-      header "__type_traits/is_bounded_array.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_callable {
-      header "__type_traits/is_callable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_char_like_type {
-      header "__type_traits/is_char_like_type.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_class {
-      header "__type_traits/is_class.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_compound {
-      header "__type_traits/is_compound.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_const {
-      header "__type_traits/is_const.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_constant_evaluated {
-      header "__type_traits/is_constant_evaluated.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_constructible {
-      header "__type_traits/is_constructible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_convertible {
-      header "__type_traits/is_convertible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_core_convertible {
-      header "__type_traits/is_core_convertible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_destructible {
-      header "__type_traits/is_destructible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_empty {
-      header "__type_traits/is_empty.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_enum {
-      header "__type_traits/is_enum.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_equality_comparable {
-      header "__type_traits/is_equality_comparable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_execution_policy {
-      header "__type_traits/is_execution_policy.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_final {
-      header "__type_traits/is_final.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_floating_point {
-      header "__type_traits/is_floating_point.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_function {
-      header "__type_traits/is_function.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_fundamental {
-      header "__type_traits/is_fundamental.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_implicitly_default_constructible {
-      header "__type_traits/is_implicitly_default_constructible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_integral {
-      header "__type_traits/is_integral.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_literal_type {
-      header "__type_traits/is_literal_type.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_member_pointer {
-      header "__type_traits/is_member_pointer.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_nothrow_assignable {
-      header "__type_traits/is_nothrow_assignable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_nothrow_constructible {
-      header "__type_traits/is_nothrow_constructible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_nothrow_convertible {
-      header "__type_traits/is_nothrow_convertible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_nothrow_destructible {
-      header "__type_traits/is_nothrow_destructible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_null_pointer {
-      header "__type_traits/is_null_pointer.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_object {
-      header "__type_traits/is_object.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_pod {
-      header "__type_traits/is_pod.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_pointer {
-      header "__type_traits/is_pointer.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_polymorphic {
-      header "__type_traits/is_polymorphic.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_primary_template {
-      header "__type_traits/is_primary_template.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_reference_wrapper {
-      header "__type_traits/is_reference_wrapper.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_reference {
-      header "__type_traits/is_reference.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_referenceable {
-      header "__type_traits/is_referenceable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_same {
-      header "__type_traits/is_same.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_scalar {
-      header "__type_traits/is_scalar.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_signed_integer {
-      header "__type_traits/is_signed_integer.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_signed {
-      header "__type_traits/is_signed.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_specialization {
-      header "__type_traits/is_specialization.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_standard_layout {
-      header "__type_traits/is_standard_layout.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_swappable {
-      header "__type_traits/is_swappable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_trivial {
-      header "__type_traits/is_trivial.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_trivially_assignable {
-      header "__type_traits/is_trivially_assignable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_trivially_constructible {
-      header "__type_traits/is_trivially_constructible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_trivially_copyable {
-      header "__type_traits/is_trivially_copyable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_trivially_destructible {
-      header "__type_traits/is_trivially_destructible.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_trivially_lexicographically_comparable {
-      header "__type_traits/is_trivially_lexicographically_comparable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_trivially_relocatable {
-      header "__type_traits/is_trivially_relocatable.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_unbounded_array {
-      header "__type_traits/is_unbounded_array.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_union {
-      header "__type_traits/is_union.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_unsigned_integer {
-      header "__type_traits/is_unsigned_integer.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_unsigned {
-      header "__type_traits/is_unsigned.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_valid_expansion {
-      header "__type_traits/is_valid_expansion.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_void {
-      header "__type_traits/is_void.h"
-      export std_core.type_traits.integral_constant
-    }
-    module is_volatile {
-      header "__type_traits/is_volatile.h"
-      export std_core.type_traits.integral_constant
-    }
-    module lazy                                       { header "__type_traits/lazy.h" }
-    module make_32_64_or_128_bit                      { header "__type_traits/make_32_64_or_128_bit.h" }
-    module make_const_lvalue_ref                      { header "__type_traits/make_const_lvalue_ref.h" }
-    module make_signed                                { header "__type_traits/make_signed.h" }
-    module make_unsigned                              { header "__type_traits/make_unsigned.h" }
-    module maybe_const                                { header "__type_traits/maybe_const.h" }
-    module nat                                        { header "__type_traits/nat.h" }
-    module negation                                   { header "__type_traits/negation.h" }
-    module promote                                    { header "__type_traits/promote.h" }
-    module rank                                       { header "__type_traits/rank.h" }
-    module remove_all_extents                         { header "__type_traits/remove_all_extents.h" }
-    module remove_const_ref                           { header "__type_traits/remove_const_ref.h" }
-    module remove_const                               { header "__type_traits/remove_const.h" }
-    module remove_cv                                  { header "__type_traits/remove_cv.h" }
-    module remove_cvref                               { header "__type_traits/remove_cvref.h" }
-    module remove_extent                              { header "__type_traits/remove_extent.h" }
-    module remove_pointer                             { header "__type_traits/remove_pointer.h" }
-    module remove_reference                           { header "__type_traits/remove_reference.h" }
-    module remove_volatile                            { header "__type_traits/remove_volatile.h" }
-    module result_of                                  { header "__type_traits/result_of.h" }
-    module strip_signature                            { header "__type_traits/strip_signature.h" }
-    module type_identity                              { header "__type_traits/type_identity.h" }
-    module type_list                                  { header "__type_traits/type_list.h" }
-    module underlying_type                            { header "__type_traits/underlying_type.h" }
-    module unwrap_ref                                 { header "__type_traits/unwrap_ref.h" }
-    module void_t                                     { header "__type_traits/void_t.h" }
-
-    header "type_traits"
-    export *
-  } // module type_traits
-
-  // Only the truly dependency-free parts of __utility are here
-  module utility_core {
-    module declval  { header "__utility/declval.h" }
-    module empty    { header "__utility/empty.h" }
-    module forward  { header "__utility/forward.h" }
-  }
-} // module std_core
-
-module std [system] {
-  module algorithm {
-    module adjacent_find                          { header "__algorithm/adjacent_find.h" }
-    module all_of                                 { header "__algorithm/all_of.h" }
-    module any_of                                 { header "__algorithm/any_of.h" }
-    module binary_search                          { header "__algorithm/binary_search.h" }
-    module clamp                                  { header "__algorithm/clamp.h" }
-    module comp_ref_type                          { header "__algorithm/comp_ref_type.h" }
-    module comp                                   { header "__algorithm/comp.h" }
-    module copy_backward                          { header "__algorithm/copy_backward.h" }
-    module copy_if                                { header "__algorithm/copy_if.h" }
-    module copy_move_common                       { header "__algorithm/copy_move_common.h" }
-    module copy_n                                 { header "__algorithm/copy_n.h" }
-    module copy                                   { header "__algorithm/copy.h" }
-    module count_if                               { header "__algorithm/count_if.h" }
-    module count                                  { header "__algorithm/count.h" }
-    module equal_range                            { header "__algorithm/equal_range.h" }
-    module equal                                  { header "__algorithm/equal.h" }
-    module fill_n                                 { header "__algorithm/fill_n.h" }
-    module fill                                   { header "__algorithm/fill.h" }
-    module find_end                               { header "__algorithm/find_end.h" }
-    module find_first_of                          { header "__algorithm/find_first_of.h" }
-    module find_if_not                            { header "__algorithm/find_if_not.h" }
-    module find_if                                { header "__algorithm/find_if.h" }
-    module find_segment_if                        { header "__algorithm/find_segment_if.h" }
-    module find                                   { header "__algorithm/find.h" }
-    module fold                                   { header "__algorithm/fold.h" }
-    module for_each_n                             { header "__algorithm/for_each_n.h" }
-    module for_each_segment                       { header "__algorithm/for_each_segment.h" }
-    module for_each                               { header "__algorithm/for_each.h" }
-    module generate_n                             { header "__algorithm/generate_n.h" }
-    module generate                               { header "__algorithm/generate.h" }
-    module half_positive                          { header "__algorithm/half_positive.h" }
-    module in_found_result                        { header "__algorithm/in_found_result.h" }
-    module in_fun_result                          { header "__algorithm/in_fun_result.h" }
-    module in_in_out_result                       { header "__algorithm/in_in_out_result.h" }
-    module in_in_result                           { header "__algorithm/in_in_result.h" }
-    module in_out_out_result                      { header "__algorithm/in_out_out_result.h" }
-    module in_out_result                          { header "__algorithm/in_out_result.h" }
-    module includes                               { header "__algorithm/includes.h" }
-    module inplace_merge                          { header "__algorithm/inplace_merge.h" }
-    module is_heap_until                          { header "__algorithm/is_heap_until.h" }
-    module is_heap                                { header "__algorithm/is_heap.h" }
-    module is_partitioned                         { header "__algorithm/is_partitioned.h" }
-    module is_permutation                         { header "__algorithm/is_permutation.h" }
-    module is_sorted_until                        { header "__algorithm/is_sorted_until.h" }
-    module is_sorted                              { header "__algorithm/is_sorted.h" }
-    module iter_swap                              { header "__algorithm/iter_swap.h" }
-    module iterator_operations {
-      header "__algorithm/iterator_operations.h"
-      export std.iterator.advance
-      export std.iterator.distance
-      export std.iterator.iter_move
-      export std.iterator.iter_swap
-      export std.iterator.next
-      export std.iterator.prev
-    }
-    module lexicographical_compare_three_way      { header "__algorithm/lexicographical_compare_three_way.h" }
-    module lexicographical_compare                { header "__algorithm/lexicographical_compare.h" }
-    module lower_bound                            { header "__algorithm/lower_bound.h" }
-    module make_heap                              { header "__algorithm/make_heap.h" }
-    module make_projected                         { header "__algorithm/make_projected.h" }
-    module max_element                            { header "__algorithm/max_element.h" }
-    module max                                    { header "__algorithm/max.h" }
-    module merge                                  { header "__algorithm/merge.h" }
-    module min_element                            { header "__algorithm/min_element.h" }
-    module min_max_result                         { header "__algorithm/min_max_result.h" }
-    module min                                    { header "__algorithm/min.h" }
-    module minmax_element                         { header "__algorithm/minmax_element.h" }
-    module minmax {
-      header "__algorithm/minmax.h"
-      export std.utility.pair // return type
-    }
-    module mismatch {
-      header "__algorithm/mismatch.h"
-      export std.utility.pair // return type
-    }
-    module move_backward                          { header "__algorithm/move_backward.h" }
-    module move                                   { header "__algorithm/move.h" }
-    module next_permutation                       { header "__algorithm/next_permutation.h" }
-    module none_of                                { header "__algorithm/none_of.h" }
-    module nth_element                            { header "__algorithm/nth_element.h" }
-    module partial_sort_copy                      { header "__algorithm/partial_sort_copy.h" }
-    module partial_sort                           { header "__algorithm/partial_sort.h" }
-    module partition_copy                         { header "__algorithm/partition_copy.h" }
-    module partition_point                        { header "__algorithm/partition_point.h" }
-    module partition                              { header "__algorithm/partition.h" }
-    module pop_heap                               { header "__algorithm/pop_heap.h" }
-    module prev_permutation                       { header "__algorithm/prev_permutation.h" }
-    module pstl                                   { header "__algorithm/pstl.h" }
-    module push_heap                              { header "__algorithm/push_heap.h" }
-    module ranges_adjacent_find                   { header "__algorithm/ranges_adjacent_find.h" }
-    module ranges_all_of                          { header "__algorithm/ranges_all_of.h" }
-    module ranges_any_of                          { header "__algorithm/ranges_any_of.h" }
-    module ranges_binary_search {
-      header "__algorithm/ranges_binary_search.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_clamp {
-      header "__algorithm/ranges_clamp.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_contains_subrange {
-      header "__algorithm/ranges_contains_subrange.h"
-    }
-    module ranges_contains {
-      header "__algorithm/ranges_contains.h"
-    }
-    module ranges_copy_backward {
-      header "__algorithm/ranges_copy_backward.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_copy_if {
-      header "__algorithm/ranges_copy_if.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_copy_n {
-      header "__algorithm/ranges_copy_n.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_copy {
-      header "__algorithm/ranges_copy.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_count_if                        { header "__algorithm/ranges_count_if.h" }
-    module ranges_count                           { header "__algorithm/ranges_count.h" }
-    module ranges_ends_with                       { header "__algorithm/ranges_ends_with.h" }
-    module ranges_equal_range {
-      header "__algorithm/ranges_equal_range.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_equal {
-      header "__algorithm/ranges_equal.h"
-      export std.functional.identity
-    }
-    module ranges_fill_n                          { header "__algorithm/ranges_fill_n.h" }
-    module ranges_fill                            { header "__algorithm/ranges_fill.h" }
-    module ranges_find_end                        { header "__algorithm/ranges_find_end.h" }
-    module ranges_find_first_of                   { header "__algorithm/ranges_find_first_of.h" }
-    module ranges_find_if_not                     { header "__algorithm/ranges_find_if_not.h" }
-    module ranges_find_if                         { header "__algorithm/ranges_find_if.h" }
-    module ranges_find_last                       { header "__algorithm/ranges_find_last.h" }
-    module ranges_find                            { header "__algorithm/ranges_find.h" }
-    module ranges_for_each_n {
-      header "__algorithm/ranges_for_each_n.h"
-      export std.algorithm.in_fun_result
-    }
-    module ranges_for_each {
-      header "__algorithm/ranges_for_each.h"
-      export std.algorithm.in_fun_result
-    }
-    module ranges_generate_n {
-      header "__algorithm/ranges_generate_n.h"
-    }
-    module ranges_generate {
-      header "__algorithm/ranges_generate.h"
-    }
-    module ranges_includes {
-      header "__algorithm/ranges_includes.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_inplace_merge {
-      header "__algorithm/ranges_inplace_merge.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_is_heap_until {
-      header "__algorithm/ranges_is_heap_until.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_is_heap {
-      header "__algorithm/ranges_is_heap.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_is_partitioned {
-      header "__algorithm/ranges_is_partitioned.h"
-    }
-    module ranges_is_permutation {
-      header "__algorithm/ranges_is_permutation.h"
-    }
-    module ranges_is_sorted_until {
-      header "__algorithm/ranges_is_sorted_until.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_is_sorted {
-      header "__algorithm/ranges_is_sorted.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_iterator_concept {
-      header "__algorithm/ranges_iterator_concept.h"
-    }
-    module ranges_lexicographical_compare {
-      header "__algorithm/ranges_lexicographical_compare.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_lower_bound {
-      header "__algorithm/ranges_lower_bound.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_make_heap {
-      header "__algorithm/ranges_make_heap.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_max_element {
-      header "__algorithm/ranges_max_element.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_max {
-      header "__algorithm/ranges_max.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_merge {
-      header "__algorithm/ranges_merge.h"
-      export std.functional.ranges_operations
-      export std.algorithm.in_in_out_result
-    }
-    module ranges_min_element {
-      header "__algorithm/ranges_min_element.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_min {
-      header "__algorithm/ranges_min.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_minmax_element {
-      header "__algorithm/ranges_minmax_element.h"
-      export std.functional.ranges_operations
-      export std.algorithm.min_max_result
-    }
-    module ranges_minmax {
-      header "__algorithm/ranges_minmax.h"
-      export std.functional.ranges_operations
-      export std.algorithm.min_max_result
-    }
-    module ranges_mismatch {
-      header "__algorithm/ranges_mismatch.h"
-      export std.algorithm.in_in_result
-    }
-    module ranges_move_backward {
-      header "__algorithm/ranges_move_backward.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_move {
-      header "__algorithm/ranges_move.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_next_permutation {
-      header "__algorithm/ranges_next_permutation.h"
-      export std.functional.ranges_operations
-      export std.algorithm.in_found_result
-    }
-    module ranges_none_of {
-      header "__algorithm/ranges_none_of.h"
-    }
-    module ranges_nth_element {
-      header "__algorithm/ranges_nth_element.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_partial_sort_copy {
-      header "__algorithm/ranges_partial_sort_copy.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_partial_sort {
-      header "__algorithm/ranges_partial_sort.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_partition_copy {
-      header "__algorithm/ranges_partition_copy.h"
-      export std.algorithm.in_out_out_result
-    }
-    module ranges_partition_point {
-      header "__algorithm/ranges_partition_point.h"
-    }
-    module ranges_partition {
-      header "__algorithm/ranges_partition.h"
-    }
-    module ranges_pop_heap {
-      header "__algorithm/ranges_pop_heap.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_prev_permutation {
-      header "__algorithm/ranges_prev_permutation.h"
-      export std.functional.ranges_operations
-      export std.algorithm.in_found_result
-    }
-    module ranges_push_heap {
-      header "__algorithm/ranges_push_heap.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_remove_copy_if {
-      header "__algorithm/ranges_remove_copy_if.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_remove_copy {
-      header "__algorithm/ranges_remove_copy.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_remove_if {
-      header "__algorithm/ranges_remove_if.h"
-    }
-    module ranges_remove {
-      header "__algorithm/ranges_remove.h"
-    }
-    module ranges_replace_copy_if {
-      header "__algorithm/ranges_replace_copy_if.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_replace_copy {
-      header "__algorithm/ranges_replace_copy.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_replace_if {
-      header "__algorithm/ranges_replace_if.h"
-    }
-    module ranges_replace {
-      header "__algorithm/ranges_replace.h"
-    }
-    module ranges_reverse_copy {
-      header "__algorithm/ranges_reverse_copy.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_reverse {
-      header "__algorithm/ranges_reverse.h"
-    }
-    module ranges_rotate_copy {
-      header "__algorithm/ranges_rotate_copy.h"
-      export std.algorithm.in_out_result
-    }
-    module ranges_rotate                          { header "__algorithm/ranges_rotate.h" }
-    module ranges_sample                          { header "__algorithm/ranges_sample.h" }
-    module ranges_search_n                        { header "__algorithm/ranges_search_n.h" }
-    module ranges_search                          { header "__algorithm/ranges_search.h" }
-    module ranges_set_difference {
-      header "__algorithm/ranges_set_difference.h"
-      export std.functional.ranges_operations
-      export std.algorithm.in_out_result
-    }
-    module ranges_set_intersection {
-      header "__algorithm/ranges_set_intersection.h"
-      export std.functional.ranges_operations
-      export std.algorithm.in_in_out_result
-    }
-    module ranges_set_symmetric_difference {
-      header "__algorithm/ranges_set_symmetric_difference.h"
-      export std.functional.ranges_operations
-      export std.algorithm.in_in_out_result
-    }
-    module ranges_set_union {
-      header "__algorithm/ranges_set_union.h"
-      export std.functional.ranges_operations
-      export std.algorithm.in_in_out_result
-    }
-    module ranges_shuffle {
-      header "__algorithm/ranges_shuffle.h"
-    }
-    module ranges_sort_heap {
-      header "__algorithm/ranges_sort_heap.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_sort {
-      header "__algorithm/ranges_sort.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_stable_partition {
-      header "__algorithm/ranges_stable_partition.h"
-    }
-    module ranges_stable_sort {
-      header "__algorithm/ranges_stable_sort.h"
-      export std.functional.ranges_operations
-    }
-    module ranges_starts_with {
-      header "__algorithm/ranges_starts_with.h"
-    }
-    module ranges_swap_ranges {
-      header "__algorithm/ranges_swap_ranges.h"
-      export std.algorithm.in_in_result
-    }
-    module ranges_transform {
-      header "__algorithm/ranges_transform.h"
-      export std.algorithm.in_out_result
-      export std.algorithm.in_in_out_result
-    }
-    module ranges_unique_copy {
-      header "__algorithm/ranges_unique_copy.h"
-    }
-    module ranges_unique {
-      header "__algorithm/ranges_unique.h"
-    }
-    module ranges_upper_bound {
-      header "__algorithm/ranges_upper_bound.h"
-      export std.functional.ranges_operations
-    }
-    module remove_copy_if                         { header "__algorithm/remove_copy_if.h" }
-    module remove_copy                            { header "__algorithm/remove_copy.h" }
-    module remove_if                              { header "__algorithm/remove_if.h" }
-    module remove                                 { header "__algorithm/remove.h" }
-    module replace_copy_if                        { header "__algorithm/replace_copy_if.h" }
-    module replace_copy                           { header "__algorithm/replace_copy.h" }
-    module replace_if                             { header "__algorithm/replace_if.h" }
-    module replace                                { header "__algorithm/replace.h" }
-    module reverse_copy                           { header "__algorithm/reverse_copy.h" }
-    module reverse                                { header "__algorithm/reverse.h" }
-    module rotate_copy                            { header "__algorithm/rotate_copy.h" }
-    module rotate                                 { header "__algorithm/rotate.h" }
-    module sample                                 { header "__algorithm/sample.h" }
-    module search_n                               { header "__algorithm/search_n.h" }
-    module search                                 { header "__algorithm/search.h" }
-    module set_difference                         { header "__algorithm/set_difference.h" }
-    module set_intersection                       { header "__algorithm/set_intersection.h" }
-    module set_symmetric_difference               { header "__algorithm/set_symmetric_difference.h" }
-    module set_union                              { header "__algorithm/set_union.h" }
-    module shift_left                             { header "__algorithm/shift_left.h" }
-    module shift_right                            { header "__algorithm/shift_right.h" }
-    module shuffle                                { header "__algorithm/shuffle.h" }
-    module sift_down                              { header "__algorithm/sift_down.h" }
-    module simd_utils                             { header "__algorithm/simd_utils.h" }
-    module sort_heap                              { header "__algorithm/sort_heap.h" }
-    module sort                                   { header "__algorithm/sort.h" }
-    module stable_partition                       { header "__algorithm/stable_partition.h" }
-    module stable_sort                            { header "__algorithm/stable_sort.h" }
-    module swap_ranges                            { header "__algorithm/swap_ranges.h" }
-    module three_way_comp_ref_type                { header "__algorithm/three_way_comp_ref_type.h" }
-    module transform                              { header "__algorithm/transform.h" }
-    module uniform_random_bit_generator_adaptor   { header "__algorithm/uniform_random_bit_generator_adaptor.h" }
-    module unique_copy                            { header "__algorithm/unique_copy.h" }
-    module unique                                 { header "__algorithm/unique.h" }
-    module unwrap_iter                            { header "__algorithm/unwrap_iter.h" }
-    module unwrap_range                           { header "__algorithm/unwrap_range.h" }
-    module upper_bound                            { header "__algorithm/upper_bound.h" }
-
-    header "algorithm"
-    export *
-  } // module algorithm
-
-  module any {
-    header "any"
-    export *
-  }
-
-  module array {
-    module fwd { header "__fwd/array.h" }
-
-    header "array"
-    export *
-  }
-
-  module atomic {
-    module aliases                { header "__atomic/aliases.h" }
-    module atomic_base            { header "__atomic/atomic_base.h" }
-    module atomic_flag            { header "__atomic/atomic_flag.h" }
-    module atomic_init            { header "__atomic/atomic_init.h" }
-    module atomic_lock_free       { header "__atomic/atomic_lock_free.h" }
-    module atomic_ref             { header "__atomic/atomic_ref.h" }
-    module atomic_sync            { header "__atomic/atomic_sync.h" }
-    module atomic {
-      header "__atomic/atomic.h"
-      export std.atomic.atomic_base // most of std::atomic methods are defined there
-    }
-    module check_memory_order     { header "__atomic/check_memory_order.h" }
-    module contention_t           { header "__atomic/contention_t.h" }
-    module cxx_atomic_impl        { header "__atomic/cxx_atomic_impl.h" }
-    module fence                  { header "__atomic/fence.h" }
-    module is_always_lock_free    { header "__atomic/is_always_lock_free.h" }
-    module kill_dependency        { header "__atomic/kill_dependency.h" }
-    module memory_order           { header "__atomic/memory_order.h" }
-    module to_gcc_order           { header "__atomic/to_gcc_order.h" }
-
-    header "atomic"
-    export *
-  }
-
-  module barrier {
-    header "barrier"
-    export *
-  }
-
-  module bit {
-    module bit_cast         { header "__bit/bit_cast.h" }
-    module bit_ceil         { header "__bit/bit_ceil.h" }
-    module bit_floor        { header "__bit/bit_floor.h" }
-    module bit_log2         { header "__bit/bit_log2.h" }
-    module bit_width        { header "__bit/bit_width.h" }
-    module blsr             { header "__bit/blsr.h" }
-    module byteswap         { header "__bit/byteswap.h" }
-    module countl           { header "__bit/countl.h" }
-    module countr           { header "__bit/countr.h" }
-    module endian           { header "__bit/endian.h" }
-    module has_single_bit   { header "__bit/has_single_bit.h" }
-    module invert_if        { header "__bit/invert_if.h" }
-    module popcount         { header "__bit/popcount.h" }
-    module rotate           { header "__bit/rotate.h" }
-
-    header "bit"
-    export *
-  }
-
-  module bitset {
-    header "bitset"
-    export *
-  }
-
-  module charconv {
-    module chars_format               { header "__charconv/chars_format.h" }
-    module from_chars_integral        { header "__charconv/from_chars_integral.h" }
-    module from_chars_result          { header "__charconv/from_chars_result.h" }
-    module tables                     { header "__charconv/tables.h" }
-    module to_chars                   { header "__charconv/to_chars.h" }
-    module to_chars_base_10           { header "__charconv/to_chars_base_10.h" }
-    module to_chars_floating_point    { header "__charconv/to_chars_floating_point.h" }
-    module to_chars_integral          { header "__charconv/to_chars_integral.h" }
-    module to_chars_result            { header "__charconv/to_chars_result.h" }
-    module traits                     { header "__charconv/traits.h" }
-
-    header "charconv"
-    export *
-  }
-
-  module chrono {
-    module calendar                   { header "__chrono/calendar.h" }
-    module concepts                   { header "__chrono/concepts.h" }
-    module convert_to_timespec        { header "__chrono/convert_to_timespec.h" }
-    module convert_to_tm              { header "__chrono/convert_to_tm.h" }
-    module day                        { header "__chrono/day.h" }
-    module duration                   { header "__chrono/duration.h" }
-    module exception                  { header "__chrono/exception.h" }
-    module file_clock                 { header "__chrono/file_clock.h" }
-    module formatter                  { header "__chrono/formatter.h" }
-    module hh_mm_ss                   { header "__chrono/hh_mm_ss.h" }
-    module high_resolution_clock {
-      header "__chrono/high_resolution_clock.h"
-      export *
-    }
-    module leap_second {
-      header "__chrono/leap_second.h"
-    }
-    module literals {
-      header "__chrono/literals.h"
-    }
-    module local_info {
-      header "__chrono/local_info.h"
-      export std.chrono.sys_info
-    }
-    module month_weekday              { header "__chrono/month_weekday.h" }
-    module month                      { header "__chrono/month.h" }
-    module monthday                   { header "__chrono/monthday.h" }
-    module ostream                    { header "__chrono/ostream.h" }
-    module parser_std_format_spec     { header "__chrono/parser_std_format_spec.h" }
-    module statically_widen           { header "__chrono/statically_widen.h" }
-    module steady_clock {
-      header "__chrono/steady_clock.h"
-      export std.chrono.time_point
-    }
-    module sys_info {
-      header "__chrono/sys_info.h"
-    }
-    module system_clock {
-      header "__chrono/system_clock.h"
-      export std.chrono.time_point
-    }
-    module time_point                 { header "__chrono/time_point.h" }
-    module time_zone_link             { header "__chrono/time_zone_link.h" }
-    module time_zone                  { header "__chrono/time_zone.h" }
-    module tzdb_list {
-      header "__chrono/tzdb_list.h"
-      export std.forward_list // forward_list iterators are used to implement this API
-      export std.string_view // by-value argument of type std::string_view
-    }
-    module tzdb {
-      header "__chrono/tzdb.h"
-      export std.string // public data member of type std::string
-      export std.vector // public data members of type std::vector
-    }
-    module weekday                    { header "__chrono/weekday.h" }
-    module year_month_day             { header "__chrono/year_month_day.h" }
-    module year_month_weekday         { header "__chrono/year_month_weekday.h" }
-    module year_month                 { header "__chrono/year_month.h" }
-    module year                       { header "__chrono/year.h" }
-    module zoned_time                 { header "__chrono/zoned_time.h" }
-
-    header "chrono"
-    export *
-  } // module chrono
-
-  module codecvt {
-    header "codecvt"
-    export *
-  }
-
-  module compare {
-    module common_comparison_category       { header "__compare/common_comparison_category.h" }
-    module compare_partial_order_fallback   { header "__compare/compare_partial_order_fallback.h" }
-    module compare_strong_order_fallback    { header "__compare/compare_strong_order_fallback.h" }
-    module compare_three_way                { header "__compare/compare_three_way.h" }
-    module compare_three_way_result         { header "__compare/compare_three_way_result.h" }
-    module compare_weak_order_fallback      { header "__compare/compare_weak_order_fallback.h" }
-    module is_eq                            { header "__compare/is_eq.h" }
-    module ordering                         { header "__compare/ordering.h" }
-    module partial_order                    { header "__compare/partial_order.h" }
-    module strong_order                     { header "__compare/strong_order.h" }
-    module synth_three_way                  { header "__compare/synth_three_way.h" }
-    module three_way_comparable             { header "__compare/three_way_comparable.h" }
-    module weak_order                       { header "__compare/weak_order.h" }
-
-    header "compare"
-    export *
-  }
-
-  module complex {
-    module fwd { header "__fwd/complex.h" }
-
-    header "complex"
-    export *
-  }
-
-  module concepts {
-    module arithmetic               { header "__concepts/arithmetic.h" }
-    module assignable               { header "__concepts/assignable.h" }
-    module boolean_testable         { header "__concepts/boolean_testable.h" }
-    module class_or_enum            { header "__concepts/class_or_enum.h" }
-    module common_reference_with    { header "__concepts/common_reference_with.h" }
-    module common_with              { header "__concepts/common_with.h" }
-    module constructible            { header "__concepts/constructible.h" }
-    module convertible_to           { header "__concepts/convertible_to.h" }
-    module copyable                 { header "__concepts/copyable.h" }
-    module derived_from             { header "__concepts/derived_from.h" }
-    module destructible             { header "__concepts/destructible.h" }
-    module different_from           { header "__concepts/different_from.h" }
-    module equality_comparable      { header "__concepts/equality_comparable.h" }
-    module invocable                { header "__concepts/invocable.h" }
-    module movable                  { header "__concepts/movable.h" }
-    module predicate                { header "__concepts/predicate.h" }
-    module regular                  { header "__concepts/regular.h" }
-    module relation                 { header "__concepts/relation.h" }
-    module same_as                  { header "__concepts/same_as.h" }
-    module semiregular              { header "__concepts/semiregular.h" }
-    module swappable                { header "__concepts/swappable.h" }
-    module totally_ordered          { header "__concepts/totally_ordered.h" }
-
-    header "concepts"
-    export *
-  }
-
-  module condition_variable {
-    module condition_variable   { header "__condition_variable/condition_variable.h" }
-
-    header "condition_variable"
-    export *
-  }
-
-  module cassert {
-    textual header "cassert" // NDEBUG requires textual inclusion
-  }
-
-  module ccomplex {
-    header "ccomplex"
-    export *
-  }
-
-  module cctype {
-    header "cctype"
-    export *
-  }
-
-  module cerrno {
-    header "cerrno"
-    export *
-  }
-
-  module cfenv {
-    header "cfenv"
-    export *
-  }
-
-  module cfloat {
-    header "cfloat"
-    export *
-  }
-
-  module cinttypes {
-    header "cinttypes"
-    export *
-  }
-
-  module ciso646 {
-    header "ciso646"
-    export *
-  }
-
-  module climits {
-    header "climits"
-    export *
-  }
-
-  module clocale {
-    header "clocale"
-    export *
-  }
-
-  module cmath {
-    header "cmath"
-    export *
-  }
-
-  // TODO: Make non-textual. This seems to cause problems when compiling against Glibc.
-  module csetjmp {
-    textual header "csetjmp"
-  }
-
-  module csignal {
-    header "csignal"
-    export *
-  }
-
-  module cstdarg {
-    header "cstdarg"
-    export *
-  }
-
-  module cstdbool {
-    header "cstdbool"
-    export *
-  }
-
-  module cstddef {
-    header "cstddef"
-    export *
-  }
-
-  module cstdio {
-    header "cstdio"
-    export *
-  }
-
-  module cstdlib {
-    header "cstdlib"
-    export *
-  }
-
-  module cstring {
-    header "cstring"
-    export *
-  }
-
-  module ctgmath {
-    header "ctgmath"
-    export *
-  }
-
-  module ctime {
-    header "ctime"
-    export *
-  }
-
-  module cuchar {
-    header "cuchar"
-    export *
-  }
-
-  module cwchar {
-    header "cwchar"
-    export *
-  }
-
-  module cwctype {
-    header "cwctype"
-    export *
-  }
-
-  module deque {
-    module fwd { header "__fwd/deque.h" }
-
-    header "deque"
-    export *
-  }
-
-  module exception {
-    module exception          { header "__exception/exception.h" }
-    module exception_ptr      { header "__exception/exception_ptr.h" }
-    module nested_exception   { header "__exception/nested_exception.h" }
-    module operations         { header "__exception/operations.h" }
-    module terminate          { header "__exception/terminate.h" }
-
-    header "exception"
-    export *
-  }
-
-  module execution {
-    header "execution"
-    export *
-  }
-
-  module expected {
-    module bad_expected_access    { header "__expected/bad_expected_access.h" }
-    module expected               { header "__expected/expected.h" }
-    module unexpect               { header "__expected/unexpect.h" }
-    module unexpected             { header "__expected/unexpected.h" }
-
-    header "expected"
-    export *
-  }
-
-  module filesystem {
-    module copy_options                   { header "__filesystem/copy_options.h" }
-    module directory_entry                { header "__filesystem/directory_entry.h" }
-    module directory_iterator             { header "__filesystem/directory_iterator.h" }
-    module directory_options              { header "__filesystem/directory_options.h" }
-    module file_status                    { header "__filesystem/file_status.h" }
-    module file_time_type                 { header "__filesystem/file_time_type.h" }
-    module file_type                      { header "__filesystem/file_type.h" }
-    module filesystem_error               { header "__filesystem/filesystem_error.h" }
-    module operations                     { header "__filesystem/operations.h" }
-    module path_iterator                  { header "__filesystem/path_iterator.h" }
-    module path                           {
-      header "__filesystem/path.h"
-      export std.string // returned by various methods of filesystem::path
-    }
-    module perm_options                   { header "__filesystem/perm_options.h" }
-    module perms                          { header "__filesystem/perms.h" }
-    module recursive_directory_iterator   { header "__filesystem/recursive_directory_iterator.h" }
-    module space_info                     { header "__filesystem/space_info.h" }
-    module u8path                         { header "__filesystem/u8path.h" }
-
-    header "filesystem"
-    export *
-  }
-
-  module format {
-    module buffer                             { header "__format/buffer.h" }
-    module concepts                           { header "__format/concepts.h" }
-    module container_adaptor                  { header "__format/container_adaptor.h" }
-    module enable_insertable                  { header "__format/enable_insertable.h" }
-    module escaped_output_table               { header "__format/escaped_output_table.h" }
-    module extended_grapheme_cluster_table    { header "__format/extended_grapheme_cluster_table.h" }
-    module format_arg                         { header "__format/format_arg.h" }
-    module format_arg_store                   { header "__format/format_arg_store.h" }
-    module format_args                        { header "__format/format_args.h" }
-    module format_context {
-      header "__format/format_context.h"
-      export std.optional // default argument for __format_context_create
-    }
-    module format_error {
-      header "__format/format_error.h"
-    }
-    module format_functions {
-      header "__format/format_functions.h"
-      export std.string // returned by the functions in that header
-    }
-    module format_parse_context               { header "__format/format_parse_context.h" }
-    module format_string                      { header "__format/format_string.h" }
-    module format_to_n_result                 { header "__format/format_to_n_result.h" }
-    module formatter                          { header "__format/formatter.h" }
-    module formatter_bool                     { header "__format/formatter_bool.h" }
-    module formatter_char                     { header "__format/formatter_char.h" }
-    module formatter_floating_point           { header "__format/formatter_floating_point.h" }
-    module formatter_integer                  { header "__format/formatter_integer.h" }
-    module formatter_integral                 { header "__format/formatter_integral.h" }
-    module formatter_output                   { header "__format/formatter_output.h" }
-    module formatter_pointer                  { header "__format/formatter_pointer.h" }
-    module formatter_string                   { header "__format/formatter_string.h" }
-    module formatter_tuple                    { header "__format/formatter_tuple.h" }
-    module fwd                                { header "__fwd/format.h" }
-    module indic_conjunct_break_table         { header "__format/indic_conjunct_break_table.h" }
-    module parser_std_format_spec             { header "__format/parser_std_format_spec.h" }
-    module range_default_formatter            { header "__format/range_default_formatter.h" }
-    module range_formatter                    { header "__format/range_formatter.h" }
-    module unicode                            { header "__format/unicode.h" }
-    module width_estimation_table             { header "__format/width_estimation_table.h" }
-    module write_escaped                      { header "__format/write_escaped.h" }
-
-    header "format"
-    export *
-  } // module format
-
-  module forward_list {
-    header "forward_list"
-    export *
-  }
-
-  module fstream {
-    module fwd { header "__fwd/fstream.h" }
-
-    header "fstream"
-    export *
-  }
-
-  module functional {
-    module binary_function              { header "__functional/binary_function.h" }
-    module binary_negate                { header "__functional/binary_negate.h" }
-    module bind_back {
-      header "__functional/bind_back.h"
-      export std.functional.perfect_forward // inherited from and using its operators
-    }
-    module bind_front {
-      header "__functional/bind_front.h"
-      export std.functional.perfect_forward // inherited from and using its operators
-    }
-    module bind                         { header "__functional/bind.h" }
-    module binder1st                    { header "__functional/binder1st.h" }
-    module binder2nd                    { header "__functional/binder2nd.h" }
-    module boyer_moore_searcher {
-      header "__functional/boyer_moore_searcher.h"
-      export std.memory.shared_ptr
-    }
-    module compose {
-      header "__functional/compose.h"
-      export std.functional.perfect_forward // inherited from and using its operators
-    }
-    module default_searcher             { header "__functional/default_searcher.h" }
-    module function                     { header "__functional/function.h" }
-    module hash                         { header "__functional/hash.h" }
-    module identity                     { header "__functional/identity.h" }
-    module invoke                       { header "__functional/invoke.h" }
-    module is_transparent               { header "__functional/is_transparent.h" }
-    module mem_fn                       { header "__functional/mem_fn.h" }
-    module mem_fun_ref                  { header "__functional/mem_fun_ref.h" }
-    module not_fn {
-      header "__functional/not_fn.h"
-      export std.functional.perfect_forward // inherited from and using its operators
-    }
-    module operations                   { header "__functional/operations.h" }
-    module perfect_forward {
-      header "__functional/perfect_forward.h"
-      export std.tuple
-    }
-    module pointer_to_binary_function   { header "__functional/pointer_to_binary_function.h" }
-    module pointer_to_unary_function    { header "__functional/pointer_to_unary_function.h" }
-    module ranges_operations            { header "__functional/ranges_operations.h" }
-    module reference_wrapper            { header "__functional/reference_wrapper.h" }
-    module unary_function               { header "__functional/unary_function.h" }
-    module unary_negate                 { header "__functional/unary_negate.h" }
-    module weak_result_type             { header "__functional/weak_result_type.h" }
-
-    header "functional"
-    export *
-  } // module functional
-
-  module future {
-    header "future"
-    export *
-  }
-
-  module initializer_list {
-    header "initializer_list"
-    export *
-  }
-
-  module iomanip {
-    header "iomanip"
-    export *
-  }
-
-  module ios {
-    module fwd  { header "__fwd/ios.h" }
-    module fpos { header "__ios/fpos.h" }
-
-    header "ios"
-    export *
-  }
-
-  module iosfwd {
-    header "iosfwd"
-    export *
-  }
-
-  module iostream {
-    header "iostream"
-    export *
-  }
-
-  module istream {
-    module fwd { header "__fwd/istream.h" }
-
-    header "istream"
-    export std.ios // base class
-  }
-
-  module iterator {
-    module access                     { header "__iterator/access.h" }
-    module advance                    { header "__iterator/advance.h" }
-    module aliasing_iterator          { header "__iterator/aliasing_iterator.h" }
-    module back_insert_iterator       { header "__iterator/back_insert_iterator.h" }
-    module bounded_iter               { header "__iterator/bounded_iter.h" }
-    module common_iterator            { header "__iterator/common_iterator.h" }
-    module concepts {
-      header "__iterator/concepts.h"
-      export std_core.type_traits.common_reference
-    }
-    module counted_iterator           { header "__iterator/counted_iterator.h" }
-    module cpp17_iterator_concepts    { header "__iterator/cpp17_iterator_concepts.h" }
-    module data                       { header "__iterator/data.h" }
-    module default_sentinel           { header "__iterator/default_sentinel.h" }
-    module distance                   { header "__iterator/distance.h" }
-    module empty                      { header "__iterator/empty.h" }
-    module erase_if_container         { header "__iterator/erase_if_container.h" }
-    module front_insert_iterator      { header "__iterator/front_insert_iterator.h" }
-    module incrementable_traits       { header "__iterator/incrementable_traits.h" }
-    module indirectly_comparable      { header "__iterator/indirectly_comparable.h" }
-    module insert_iterator            { header "__iterator/insert_iterator.h" }
-    module istream_iterator           { header "__iterator/istream_iterator.h" }
-    module istreambuf_iterator        { header "__iterator/istreambuf_iterator.h" }
-    module iter_move                  { header "__iterator/iter_move.h" }
-    module iter_swap                  { header "__iterator/iter_swap.h" }
-    module iterator_traits {
-      header "__iterator/iterator_traits.h"
-      export std_core.type_traits.integral_constant
-    }
-    module iterator_with_data         { header "__iterator/iterator_with_data.h" }
-    module iterator                   { header "__iterator/iterator.h" }
-    module mergeable                  { header "__iterator/mergeable.h" }
-    module move_iterator              { header "__iterator/move_iterator.h" }
-    module move_sentinel              { header "__iterator/move_sentinel.h" }
-    module next                       { header "__iterator/next.h" }
-    module ostream_iterator           { header "__iterator/ostream_iterator.h" }
-    module ostreambuf_iterator {
-      header "__iterator/ostreambuf_iterator.h"
-      export iosfwd // for default template argument of ostreambuf_iterator
-    }
-    module permutable                 { header "__iterator/permutable.h" }
-    module prev                       { header "__iterator/prev.h" }
-    module projected                  { header "__iterator/projected.h" }
-    module ranges_iterator_traits     { header "__iterator/ranges_iterator_traits.h" }
-    module readable_traits            { header "__iterator/readable_traits.h" }
-    module reverse_access             { header "__iterator/reverse_access.h" }
-    module reverse_iterator           { header "__iterator/reverse_iterator.h" }
-    module segmented_iterator         { header "__iterator/segmented_iterator.h" }
-    module size                       { header "__iterator/size.h" }
-    module sortable                   { header "__iterator/sortable.h" }
-    module unreachable_sentinel       { header "__iterator/unreachable_sentinel.h" }
-    module wrap_iter                  { header "__iterator/wrap_iter.h" }
-
-    header "iterator"
-    export *
-  }
-
-  module latch {
-    header "latch"
-    export *
-  }
-
-  module list {
-    header "list"
-    export *
-  }
-
-  module locale {
-    header "locale"
-    header "__locale_dir/locale_base_api.h"
-    header "__locale_dir/locale_base_api/locale_guard.h"
-    module locale_base_api {
-      textual header "__locale_dir/locale_base_api/android.h"
-      textual header "__locale_dir/locale_base_api/bsd_locale_defaults.h"
-      textual header "__locale_dir/locale_base_api/bsd_locale_fallbacks.h"
-      textual header "__locale_dir/locale_base_api/fuchsia.h"
-      textual header "__locale_dir/locale_base_api/ibm.h"
-      textual header "__locale_dir/locale_base_api/musl.h"
-      textual header "__locale_dir/locale_base_api/newlib.h"
-      textual header "__locale_dir/locale_base_api/openbsd.h"
-      textual header "__locale_dir/locale_base_api/win32.h"
-    }
-    export *
-  }
-
-  // TODO: Understand why this needs to live in its own module
-  module locale_base [system] {
-    header "__locale"
-    export *
-  }
-
-  module map {
-    header "map"
-    export *
-  }
-
-  module mdspan {
-    module default_accessor   { header "__mdspan/default_accessor.h" }
-    module extents            { header "__mdspan/extents.h" }
-    module fwd                { header "__fwd/mdspan.h" }
-    module layout_left        { header "__mdspan/layout_left.h" }
-    module layout_right       { header "__mdspan/layout_right.h" }
-    module layout_stride      { header "__mdspan/layout_stride.h" }
-    module mdspan {
-      header "__mdspan/mdspan.h"
-      export std.array // returned by some methods
-    }
-
-    header "mdspan"
-    export *
-  }
-
-  module memory {
-    module addressof                          { header "__memory/addressof.h" }
-    module align                              { header "__memory/align.h" }
-    module aligned_alloc                      { header "__memory/aligned_alloc.h" }
-    module allocate_at_least                  { header "__memory/allocate_at_least.h" }
-    module allocation_guard                   { header "__memory/allocation_guard.h" }
-    module allocator                          { header "__memory/allocator.h" }
-    module allocator_arg_t                    { header "__memory/allocator_arg_t.h" }
-    module allocator_destructor               { header "__memory/allocator_destructor.h" }
-    module allocator_traits                   { header "__memory/allocator_traits.h" }
-    module assume_aligned                     { header "__memory/assume_aligned.h" }
-    module auto_ptr                           { header "__memory/auto_ptr.h" }
-    module builtin_new_allocator              { header "__memory/builtin_new_allocator.h" }
-    module compressed_pair                    { header "__memory/compressed_pair.h" }
-    module concepts                           { header "__memory/concepts.h" }
-    module construct_at                       { header "__memory/construct_at.h" }
-    module destruct_n                         { header "__memory/destruct_n.h" }
-    module fwd                                { header "__fwd/memory.h" }
-    module inout_ptr                          { header "__memory/inout_ptr.h" }
-    module noexcept_move_assign_container     { header "__memory/noexcept_move_assign_container.h" }
-    module out_ptr                            { header "__memory/out_ptr.h" }
-    module pointer_traits                     { header "__memory/pointer_traits.h" }
-    module ranges_construct_at                { header "__memory/ranges_construct_at.h" }
-    module ranges_uninitialized_algorithms {
-      header "__memory/ranges_uninitialized_algorithms.h"
-      export std.algorithm.in_out_result
-    }
-    module raw_storage_iterator               { header "__memory/raw_storage_iterator.h" }
-    module shared_ptr                         { header "__memory/shared_ptr.h" }
-    module swap_allocator                     { header "__memory/swap_allocator.h" }
-    module temp_value                         { header "__memory/temp_value.h" }
-    module temporary_buffer                   {
-      header "__memory/temporary_buffer.h"
-      export std.utility.pair // return type of std::get_temporary_buffer()
-    }
-    module uninitialized_algorithms {
-      header "__memory/uninitialized_algorithms.h"
-    }
-    module unique_ptr {
-      header "__memory/unique_ptr.h"
-    }
-    module unique_temporary_buffer {
-      header "__memory/unique_temporary_buffer.h"
-      export std.memory.unique_ptr
-      export std_core.type_traits.is_constant_evaluated
-    }
-    module uses_allocator                     { header "__memory/uses_allocator.h" }
-    module uses_allocator_construction        { header "__memory/uses_allocator_construction.h" }
-    module voidify                            { header "__memory/voidify.h" }
-
-    header "memory"
-    export *
-  }
-
-  module memory_resource {
-    module fwd                            { header "__fwd/memory_resource.h" }
-    module memory_resource                { header "__memory_resource/memory_resource.h" }
-    module monotonic_buffer_resource      { header "__memory_resource/monotonic_buffer_resource.h" }
-    module polymorphic_allocator          { header "__memory_resource/polymorphic_allocator.h" }
-    module pool_options                   { header "__memory_resource/pool_options.h" }
-    module synchronized_pool_resource     { header "__memory_resource/synchronized_pool_resource.h" }
-    module unsynchronized_pool_resource   { header "__memory_resource/unsynchronized_pool_resource.h" }
-
-    header "memory_resource"
-    export *
-  }
-
-  module mutex {
-    module lock_guard     { header "__mutex/lock_guard.h" }
-    module mutex          { header "__mutex/mutex.h" }
-    module once_flag      { header "__mutex/once_flag.h" }
-    module tag_types      { header "__mutex/tag_types.h" }
-    module unique_lock    { header "__mutex/unique_lock.h" }
-
-    header "mutex"
-    export *
-  }
-
-  module new {
-    header "new"
-    export *
-  }
-
-  module numbers {
-    header "numbers"
-    export *
-  }
-
-  module numeric {
-    module accumulate                 { header "__numeric/accumulate.h" }
-    module adjacent_difference        { header "__numeric/adjacent_difference.h" }
-    module exclusive_scan             { header "__numeric/exclusive_scan.h" }
-    module gcd_lcm                    { header "__numeric/gcd_lcm.h" }
-    module inclusive_scan             { header "__numeric/inclusive_scan.h" }
-    module inner_product              { header "__numeric/inner_product.h" }
-    module iota                       { header "__numeric/iota.h" }
-    module midpoint                   { header "__numeric/midpoint.h" }
-    module partial_sum                { header "__numeric/partial_sum.h" }
-    module pstl                       { header "__numeric/pstl.h" }
-    module reduce                     { header "__numeric/reduce.h" }
-    module saturation_arithmetic      { header "__numeric/saturation_arithmetic.h" }
-    module transform_exclusive_scan   { header "__numeric/transform_exclusive_scan.h" }
-    module transform_inclusive_scan   { header "__numeric/transform_inclusive_scan.h" }
-    module transform_reduce           { header "__numeric/transform_reduce.h" }
-
-    header "numeric"
-    export *
-  }
-
-  module optional {
-    header "optional"
-    export *
-  }
-
-  module ostream {
-    module basic_ostream {
-      header "__ostream/basic_ostream.h"
-      export std.ios // base class
-    }
-    module fwd {
-      header "__fwd/ostream.h"
-    }
-    module print {
-      header "__ostream/print.h"
-      export *
-    }
-
-    header "ostream"
-    export *
-  }
-
-  module print {
-    header "print"
-    export *
-  }
-
-  module queue {
-    module fwd { header "__fwd/queue.h" }
-
-    header "queue"
-    export *
-  }
-
-  module random {
-    module bernoulli_distribution             { header "__random/bernoulli_distribution.h" }
-    module binomial_distribution              { header "__random/binomial_distribution.h" }
-    module cauchy_distribution                { header "__random/cauchy_distribution.h" }
-    module chi_squared_distribution           { header "__random/chi_squared_distribution.h" }
-    module clamp_to_integral                  { header "__random/clamp_to_integral.h" }
-    module default_random_engine              { header "__random/default_random_engine.h" }
-    module discard_block_engine               { header "__random/discard_block_engine.h" }
-    module discrete_distribution              { header "__random/discrete_distribution.h" }
-    module exponential_distribution           { header "__random/exponential_distribution.h" }
-    module extreme_value_distribution         { header "__random/extreme_value_distribution.h" }
-    module fisher_f_distribution              { header "__random/fisher_f_distribution.h" }
-    module gamma_distribution                 { header "__random/gamma_distribution.h" }
-    module generate_canonical                 { header "__random/generate_canonical.h" }
-    module geometric_distribution             { header "__random/geometric_distribution.h" }
-    module independent_bits_engine            { header "__random/independent_bits_engine.h" }
-    module is_seed_sequence                   { header "__random/is_seed_sequence.h" }
-    module is_valid {
-      header "__random/is_valid.h"
-      export std_core.type_traits.integral_constant
-    }
-    module knuth_b                            { header "__random/knuth_b.h" }
-    module linear_congruential_engine         { header "__random/linear_congruential_engine.h" }
-    module log2                               { header "__random/log2.h" }
-    module lognormal_distribution             { header "__random/lognormal_distribution.h" }
-    module mersenne_twister_engine            { header "__random/mersenne_twister_engine.h" }
-    module negative_binomial_distribution     { header "__random/negative_binomial_distribution.h" }
-    module normal_distribution                { header "__random/normal_distribution.h" }
-    module piecewise_constant_distribution    { header "__random/piecewise_constant_distribution.h" }
-    module piecewise_linear_distribution      { header "__random/piecewise_linear_distribution.h" }
-    module poisson_distribution               { header "__random/poisson_distribution.h" }
-    module random_device                      { header "__random/random_device.h" }
-    module ranlux                             { header "__random/ranlux.h" }
-    module seed_seq                           { header "__random/seed_seq.h" }
-    module shuffle_order_engine               { header "__random/shuffle_order_engine.h" }
-    module student_t_distribution             { header "__random/student_t_distribution.h" }
-    module subtract_with_carry_engine         { header "__random/subtract_with_carry_engine.h" }
-    module uniform_int_distribution           { header "__random/uniform_int_distribution.h" }
-    module uniform_random_bit_generator       { header "__random/uniform_random_bit_generator.h" }
-    module uniform_real_distribution          { header "__random/uniform_real_distribution.h" }
-    module weibull_distribution               { header "__random/weibull_distribution.h" }
-
-    header "random"
-    export *
-  }
-
-  module ranges {
-    module access                         { header "__ranges/access.h" }
-    module all                            { header "__ranges/all.h" }
-    module as_rvalue_view                 { header "__ranges/as_rvalue_view.h" }
-    module chunk_by_view {
-      header "__ranges/chunk_by_view.h"
-      export std.functional.bind_back
-    }
-    module common_view                    { header "__ranges/common_view.h" }
-    module concepts                       { header "__ranges/concepts.h" }
-    module container_compatible_range     { header "__ranges/container_compatible_range.h" }
-    module counted {
-      header "__ranges/counted.h"
-      export std.span            // return type of views::counted
-      export std.ranges.subrange // return type of views::counted
-    }
-    module dangling {
-      header "__ranges/dangling.h"
-    }
-    module data {
-      header "__ranges/data.h"
-    }
-    module drop_view {
-      header "__ranges/drop_view.h"
-      export std.functional.bind_back
-    }
-    module drop_while_view {
-      header "__ranges/drop_while_view.h"
-      export std.functional.bind_back
-    }
-    module elements_view                  { header "__ranges/elements_view.h" }
-    module empty                          { header "__ranges/empty.h" }
-    module empty_view                     { header "__ranges/empty_view.h" }
-    module enable_borrowed_range          { header "__ranges/enable_borrowed_range.h" }
-    module enable_view                    { header "__ranges/enable_view.h" }
-    module filter_view {
-      header "__ranges/filter_view.h"
-      export std.functional.bind_back
-    }
-    module from_range                     { header "__ranges/from_range.h" }
-    module iota_view                      { header "__ranges/iota_view.h" }
-    module istream_view                   { header "__ranges/istream_view.h" }
-    module join_view                      { header "__ranges/join_view.h" }
-    module lazy_split_view {
-      header "__ranges/lazy_split_view.h"
-      export std.functional.bind_back
-    }
-    module movable_box                    { header "__ranges/movable_box.h" }
-    module non_propagating_cache          { header "__ranges/non_propagating_cache.h" }
-    module owning_view                    { header "__ranges/owning_view.h" }
-    module range_adaptor                  { header "__ranges/range_adaptor.h" }
-    module rbegin                         { header "__ranges/rbegin.h" }
-    module ref_view                       { header "__ranges/ref_view.h" }
-    module rend                           { header "__ranges/rend.h" }
-    module repeat_view                    { header "__ranges/repeat_view.h" }
-    module reverse_view                   { header "__ranges/reverse_view.h" }
-    module single_view                    { header "__ranges/single_view.h" }
-    module size                           { header "__ranges/size.h" }
-    module split_view {
-      header "__ranges/split_view.h"
-      export std.functional.bind_back
-    }
-    module subrange {
-      header "__ranges/subrange.h"
-      export std.ranges.subrange_fwd
-    }
-    module subrange_fwd {
-      header "__fwd/subrange.h"
-    }
-    module take_view {
-      header "__ranges/take_view.h"
-      export std.functional.bind_back
-    }
-    module take_while_view {
-      header "__ranges/take_while_view.h"
-      export std.functional.bind_back
-    }
-    module to {
-      header "__ranges/to.h"
-      export std.functional.bind_back
-    }
-    module transform_view {
-      header "__ranges/transform_view.h"
-      export std.functional.bind_back
-    }
-    module view_interface {
-      header "__ranges/view_interface.h"
-    }
-    module views {
-      header "__ranges/views.h"
-    }
-    module zip_view {
-      header "__ranges/zip_view.h"
-      export std.utility.pair
-    }
-
-    header "ranges"
-    export *
-  } // module ranges
-
-  module ratio {
-    header "ratio"
-    export *
-  }
-
-  module regex {
-    header "regex"
-    export *
-  }
-
-  module scoped_allocator {
-    header "scoped_allocator"
-    export *
-  }
-
-  module semaphore {
-    header "semaphore"
-    export *
-  }
-
-  module set {
-    header "set"
-    export *
-  }
-
-  module shared_mutex {
-    header "shared_mutex"
-    export *
-  }
-
-  module source_location {
-    header "source_location"
-    export *
-  }
-
-  module span {
-    module fwd { header "__fwd/span.h" }
-
-    header "span"
-    export *
-  }
-
-  module sstream {
-    module fwd { header "__fwd/sstream.h" }
-
-    header "sstream"
-    export *
-  }
-
-  module stack {
-    module fwd { header "__fwd/stack.h" }
-
-    header "stack"
-    export *
-  }
-
-  module stdexcept {
-    header "stdexcept"
-    export *
-  }
-
-  module stop_token {
-    module atomic_unique_lock     { header "__stop_token/atomic_unique_lock.h" }
-    module intrusive_list_view    { header "__stop_token/intrusive_list_view.h" }
-    module intrusive_shared_ptr   { header "__stop_token/intrusive_shared_ptr.h" }
-    module stop_callback          { header "__stop_token/stop_callback.h" }
-    module stop_source            { header "__stop_token/stop_source.h" }
-    module stop_state             { header "__stop_token/stop_state.h" }
-    module stop_token             { header "__stop_token/stop_token.h" }
-
-    header "stop_token"
-    export *
-  }
-
-  module streambuf {
-    module fwd { header "__fwd/streambuf.h" }
-
-    header "streambuf"
-    export *
-  }
-
-  module string {
-    module char_traits              { header "__string/char_traits.h" }
-    module constexpr_c_functions    { header "__string/constexpr_c_functions.h" }
-    module extern_template_lists    { header "__string/extern_template_lists.h" }
-    module fwd                      {  header "__fwd/string.h" }
-
-    header "string"
-    export *
-  }
-
-  module string_view {
-    module fwd { header "__fwd/string_view.h" }
-
-    header "string_view"
-    export *
-  }
-
-  module strstream {
-    header "strstream"
-    export *
-  }
-
-  module syncstream {
-    header "syncstream"
-    export *
-  }
-
-  module system_error {
-    module errc               { header "__system_error/errc.h" }
-    module error_category     { header "__system_error/error_category.h" }
-    module error_code {
-      header "__system_error/error_code.h"
-      export std.system_error.error_category // methods of error_code return that type
-    }
-    module error_condition    { header "__system_error/error_condition.h" }
-    module system_error       { header "__system_error/system_error.h" }
-
-    header "system_error"
-    export *
-  }
-
-  module thread {
-    module formatter              { header "__thread/formatter.h" }
-    module id                     { header "__thread/id.h" }
-    module jthread                { header "__thread/jthread.h" }
-    module poll_with_backoff      { header "__thread/poll_with_backoff.h" }
-    module this_thread            { header "__thread/this_thread.h" }
-    module thread                 { header "__thread/thread.h" }
-    module timed_backoff_policy   { header "__thread/timed_backoff_policy.h" }
-
-    module support {
-      header "__thread/support.h"
-      export *
-    }
-    module support_impl {
-      textual header "__thread/support/c11.h"
-      textual header "__thread/support/external.h"
-      textual header "__thread/support/pthread.h"
-      textual header "__thread/support/windows.h"
-    }
-
-    header "thread"
-    export *
-  }
-
-  module tuple {
-    module find_index               { header "__tuple/find_index.h" }
-    module ignore                   { header "__tuple/ignore.h" }
-    module make_tuple_types         { header "__tuple/make_tuple_types.h" }
-    module sfinae_helpers           { header "__tuple/sfinae_helpers.h" }
-    module tuple_element            { header "__tuple/tuple_element.h" }
-    module tuple_indices            { header "__tuple/tuple_indices.h" }
-    module tuple_like_ext           { header "__tuple/tuple_like_ext.h" }
-    module tuple_like_no_subrange   { header "__tuple/tuple_like_no_subrange.h" }
-    module tuple_like               { header "__tuple/tuple_like.h" }
-    module tuple_size               { header "__tuple/tuple_size.h" }
-    module tuple_types              { header "__tuple/tuple_types.h" }
-
-    header "tuple"
-    export *
+module std_any [system] {
+  header "any"
+  export *
+}
+module std_array [system] {
+  header "array"
+  export *
+}
+module std_atomic [system] {
+  header "atomic"
+  export *
+}
+module std_barrier [system] {
+  header "barrier"
+  export *
+}
+module std_bit [system] {
+  header "bit"
+  export *
+}
+module std_bitset [system] {
+  header "bitset"
+  export *
+}
+module std_charconv [system] {
+  header "charconv"
+  module chars_format            { header "__charconv/chars_format.h" }
+  module from_chars_integral     { header "__charconv/from_chars_integral.h" }
+  module from_chars_result       { header "__charconv/from_chars_result.h" }
+  module tables                  { header "__charconv/tables.h" }
+  module to_chars                { header "__charconv/to_chars.h" }
+  module to_chars_base_10        { header "__charconv/to_chars_base_10.h" }
+  module to_chars_floating_point { header "__charconv/to_chars_floating_point.h" }
+  module to_chars_integral       { header "__charconv/to_chars_integral.h" }
+  module to_chars_result         { header "__charconv/to_chars_result.h" }
+  module traits                  { header "__charconv/traits.h" }
+  export *
+}
+module std_chrono [system] {
+  header "chrono"
+  export *
+}
+module std_codecvt [system] {
+  header "codecvt"
+  export *
+}
+module std_compare [system] {
+  header "compare"
+  export *
+}
+module std_complex [system] {
+  header "complex"
+  export *
+}
+module std_concepts [system] {
+  header "concepts"
+  export *
+}
+module std_condition_variable [system] {
+  header "condition_variable"
+  module condition_variable { header "__condition_variable/condition_variable.h" }
+  export *
+}
+module std_coroutine [system] {
+  header "coroutine"
+  module coroutine_handle      { header "__coroutine/coroutine_handle.h" }
+  module coroutine_traits      { header "__coroutine/coroutine_traits.h" }
+  module noop_coroutine_handle { header "__coroutine/noop_coroutine_handle.h" }
+  module trivial_awaitables    { header "__coroutine/trivial_awaitables.h" }
+  export *
+}
+module std_deque [system] {
+  header "deque"
+  export *
+}
+module std_exception [system] {
+  header "exception"
+  export *
+}
+module std_execution [system] {
+  header "execution"
+  export *
+}
+module std_expected [system] {
+  header "expected"
+  export *
+}
+module std_filesystem [system] {
+  header "filesystem"
+  module copy_options                 { header "__filesystem/copy_options.h" }
+  module directory_entry              { header "__filesystem/directory_entry.h" }
+  module directory_iterator           { header "__filesystem/directory_iterator.h" }
+  module directory_options            { header "__filesystem/directory_options.h" }
+  module file_status                  { header "__filesystem/file_status.h" }
+  module file_time_type               { header "__filesystem/file_time_type.h" }
+  module file_type                    { header "__filesystem/file_type.h" }
+  module filesystem_error             {
+    header "__filesystem/filesystem_error.h"
+    export std_private_memory_shared_ptr
+  }
+  module operations                   { header "__filesystem/operations.h" }
+  module path                         {
+    header "__filesystem/path.h"
+    export std_string // returned by various methods
+  }
+  module path_iterator                { header "__filesystem/path_iterator.h" }
+  module perm_options                 { header "__filesystem/perm_options.h" }
+  module perms                        { header "__filesystem/perms.h" }
+  module recursive_directory_iterator { header "__filesystem/recursive_directory_iterator.h" }
+  module space_info                   { header "__filesystem/space_info.h" }
+  module u8path                       { header "__filesystem/u8path.h" }
+  export *
+}
+module std_format [system] {
+  header "format"
+  export *
+}
+module std_forward_list [system] {
+  header "forward_list"
+  export *
+}
+module std_fstream [system] {
+  header "fstream"
+  export *
+}
+module std_functional [system] {
+  header "functional"
+  export *
+}
+module std_future [system] {
+  header "future"
+  export *
+}
+module std_initializer_list [system] {
+  header "initializer_list"
+  export *
+}
+module std_iomanip [system] {
+  header "iomanip"
+  export *
+}
+module std_ios [system] {
+  header "ios"
+  export *
+}
+module std_iosfwd [system] {
+  header "iosfwd"
+  export *
+}
+module std_iostream [system] {
+  header "iostream"
+  export *
+}
+module std_istream [system] {
+  header "istream"
+  export *
+}
+module std_iterator [system] {
+  header "iterator"
+  export *
+}
+module std_latch [system] {
+  header "latch"
+  export *
+}
+module std_limits [system] {
+  header "limits"
+  export *
+}
+module std_list [system] {
+  header "list"
+  export *
+}
+module std_locale [system] {
+  header "locale"
+  export *
+}
+module std_map [system] {
+  header "map"
+  export *
+}
+module std_mdspan [system] {
+  header "mdspan"
+  module default_accessor { header "__mdspan/default_accessor.h" }
+  module extents          { header "__mdspan/extents.h" }
+  module fwd              { header "__fwd/mdspan.h" }
+  module layout_left      { header "__mdspan/layout_left.h" }
+  module layout_right     { header "__mdspan/layout_right.h" }
+  module layout_stride    { header "__mdspan/layout_stride.h" }
+  module mdspan           {
+    header "__mdspan/mdspan.h"
+    export std_array // for strides()
   }
+  export *
+}
+module std_memory [system] {
+  header "memory"
+  export *
+}
+module std_memory_resource [system] {
+  header "memory_resource"
+  export *
+}
+module std_mutex [system] {
+  header "mutex"
+  export *
+}
+module std_new [system] {
+  header "new"
+  export *
+}
+module std_numbers [system] {
+  header "numbers"
+  export *
+}
+module std_numeric [system] {
+  header "numeric"
+  export *
+}
+module std_optional [system] {
+  header "optional"
+  export *
+}
+module std_ostream [system] {
+  header "ostream"
+  export *
+}
+module std_print [system] {
+  header "print"
+  export *
+}
+module std_queue [system] {
+  header "queue"
+  export *
+}
+module std_random [system] {
+  header "random"
+  export *
+}
+module std_ranges [system] {
+  header "ranges"
+  export *
+}
+module std_ratio [system] {
+  header "ratio"
+  export *
+}
+module std_regex [system] {
+  header "regex"
+  export *
+}
+module std_scoped_allocator [system] {
+  header "scoped_allocator"
+  export *
+}
+module std_semaphore [system] {
+  header "semaphore"
+  export *
+}
+module std_set [system] {
+  header "set"
+  export *
+}
+module std_shared_mutex [system] {
+  header "shared_mutex"
+  export std_version
+}
+module std_source_location [system] {
+  header "source_location"
+  export *
+}
+module std_span [system] {
+  header "span"
+  export std_private_ranges_enable_borrowed_range
+  export std_version
+  export std_private_span_span_fwd
+}
+module std_sstream [system] {
+  header "sstream"
+  export *
+}
+module std_stack [system] {
+  header "stack"
+  export *
+}
+module std_stdexcept [system] {
+  header "stdexcept"
+  export *
+}
+module std_stop_token [system] {
+  header "stop_token"
+  private header "__stop_token/atomic_unique_lock.h"
+  private header "__stop_token/intrusive_list_view.h"
+  private header "__stop_token/intrusive_shared_ptr.h"
+  private header "__stop_token/stop_callback.h"
+  private header "__stop_token/stop_source.h"
+  private header "__stop_token/stop_state.h"
+  private header "__stop_token/stop_token.h"
+  export *
+}
+module std_streambuf [system] {
+  header "streambuf"
+  export *
+}
+module std_string [system] {
+  header "string"
+  export *
+}
+module std_string_view [system] {
+  header "string_view"
+  export *
+}
+module std_strstream [system] {
+  header "strstream"
+  export *
+}
+module std_syncstream [system] {
+  header "syncstream"
+  export *
+}
+module std_system_error [system] {
+  header "system_error"
+  export *
+}
+module std_thread [system] {
+  header "thread"
+  export *
+}
+module std_tuple [system] {
+  header "tuple"
+  export *
+}
+module std_type_traits [system] {
+  header "type_traits"
+  export *
+}
+module std_typeindex [system] {
+  header "typeindex"
+  export *
+}
+module std_typeinfo [system] {
+  header "typeinfo"
+  export *
+}
+module std_unordered_map [system] {
+  header "unordered_map"
+  export *
+}
+module std_unordered_set [system] {
+  header "unordered_set"
+  export *
+}
+module std_utility [system] {
+  header "utility"
+  export *
+}
+module std_valarray [system] {
+  header "valarray"
+  export *
+}
+module std_variant [system] {
+  header "variant"
+  export *
+}
+module std_vector [system] {
+  header "vector"
+  export *
+}
+module std_version [system] {
+  header "version"
+  export *
+}
 
-  module typeindex {
-    header "typeindex"
-    export *
-  }
+// C standard library interface wrappers
+module std_cassert [system] {
+  // <cassert>'s use of NDEBUG requires textual inclusion.
+  textual header "cassert"
+}
+module std_ccomplex [system] {
+  header "ccomplex"
+  export *
+}
+module std_cctype [system] {
+  header "cctype"
+  export *
+}
+module std_cerrno [system] {
+  header "cerrno"
+  export *
+}
+module std_cfenv [system] {
+  header "cfenv"
+  export *
+}
+module std_cfloat [system] {
+  header "cfloat"
+  export *
+}
+module std_cinttypes [system] {
+  header "cinttypes"
+  export *
+}
+module std_ciso646 [system] {
+  header "ciso646"
+  export *
+}
+module std_climits [system] {
+  header "climits"
+  export *
+}
+module std_clocale [system] {
+  header "clocale"
+  export *
+}
+module std_cmath [system] {
+  header "cmath"
+  export *
+}
+module std_csetjmp [system] {
+  header "csetjmp"
+  export *
+}
+module std_csignal [system] {
+  header "csignal"
+  export *
+}
+// FIXME: <cstdalign> is missing.
+module std_cstdarg [system] {
+  header "cstdarg"
+  export *
+}
+module std_cstdbool [system] {
+  header "cstdbool"
+  export *
+}
+module std_cstddef [system] {
+  header "cstddef"
+  module byte         { header "__cstddef/byte.h" }
+  module max_align_t  { header "__cstddef/max_align_t.h" }
+  module nullptr_t    { header "__cstddef/nullptr_t.h" }
+  module ptrdiff_t    { header "__cstddef/ptrdiff_t.h" }
+  module size_t       { header "__cstddef/size_t.h" }
+  export *
+}
+module std_cstdint [system] {
+  header "cstdint"
+  export *
+}
+module std_cstdio [system] {
+  header "cstdio"
+  export *
+}
+module std_cstdlib [system] {
+  header "cstdlib"
+  export *
+}
+module std_cstring [system] {
+  header "cstring"
+  export *
+}
+module std_ctgmath [system] {
+  header "ctgmath"
+  export *
+}
+module std_ctime [system] {
+  header "ctime"
+  export *
+}
+module std_cuchar [system] {
+  header "cuchar"
+  export *
+}
+module std_cwchar [system] {
+  header "cwchar"
+  export *
+}
+module std_cwctype [system] {
+  header "cwctype"
+  export *
+}
 
-  module typeinfo {
-    header "typeinfo"
-    export *
-  }
+// C standard library interfaces augmented/replaced in C++
+// <assert.h> provided by C library.
+module std_complex_h [system] {
+  header "complex.h"
+  export *
+}
+module std_ctype_h [system] {
+  header "ctype.h"
+  export *
+}
+module std_errno_h [system] {
+  header "errno.h"
+  export *
+}
+module std_fenv_h [system] {
+  header "fenv.h"
+  export *
+}
+module std_float_h [system] {
+  header "float.h"
+  export *
+}
+module std_inttypes_h [system] {
+  header "inttypes.h"
+  export *
+}
+// <iso646.h> provided by compiler.
+module std_locale_h [system] {
+  header "locale.h"
+  export *
+}
+module std_math_h [system] {
+  header "math.h"
+  export *
+}
+// <setjmp.h> provided by C library.
+// <signal.h> provided by C library.
+// FIXME: <stdalign.h> is missing.
+// <stdarg.h> provided by compiler.
+module std_stdatomic_h [system] {
+  header "stdatomic.h"
+  export *
+}
+module std_stdbool_h [system] {
+  // <stdbool.h>'s __bool_true_false_are_defined macro requires textual inclusion.
+  textual header "stdbool.h"
+  export *
+}
+module std_stddef_h [system] {
+  // <stddef.h>'s __need_* macros require textual inclusion.
+  textual header "stddef.h"
+  export *
+}
+module std_stdint_h [system] {
+  header "stdint.h"
+  export *
+}
+module std_stdio_h [system] {
+  // <stdio.h>'s __need_* macros require textual inclusion.
+  textual header "stdio.h"
+  export *
+}
+module std_stdlib_h [system] {
+  // <stdlib.h>'s __need_* macros require textual inclusion.
+  textual header "stdlib.h"
+  export *
+}
+module std_string_h [system] {
+  header "string.h"
+  export *
+}
+module std_tgmath_h [system] {
+  header "tgmath.h"
+  export *
+}
+module std_uchar_h [system] {
+  header "uchar.h"
+  export *
+}
+// <time.h> provided by C library.
+module std_wchar_h [system] {
+  // <wchar.h>'s __need_* macros require textual inclusion.
+  textual header "wchar.h"
+  export *
+}
+module std_wctype_h [system] {
+  header "wctype.h"
+  export *
+}
 
-  module unordered_map {
-    header "unordered_map"
+// Experimental C++ standard library interfaces
+module std_experimental [system] {
+  module iterator {
+    header "experimental/iterator"
     export *
   }
-
-  module unordered_set {
-    header "unordered_set"
+  module memory {
+    header "experimental/memory"
     export *
   }
-
-  module utility {
-    module as_const                   { header "__utility/as_const.h" }
-    module as_lvalue                  { header "__utility/as_lvalue.h" }
-    module auto_cast                  {
-      header "__utility/auto_cast.h"
-      export std_core.type_traits.decay // the macro expansion uses that trait
-    }
-    module cmp                        { header "__utility/cmp.h" }
-    module convert_to_integral        { header "__utility/convert_to_integral.h" }
-    module exception_guard            { header "__utility/exception_guard.h" }
-    module exchange                   { header "__utility/exchange.h" }
-    module forward_like               { header "__utility/forward_like.h" }
-    module in_place {
-      header "__utility/in_place.h"
-      export std_core.type_traits.integral_constant
-    }
-    module integer_sequence           { header "__utility/integer_sequence.h" }
-    module is_pointer_in_range        { header "__utility/is_pointer_in_range.h" }
-    module is_valid_range             { header "__utility/is_valid_range.h" }
-    module move                       { header "__utility/move.h" }
-    module no_destroy                 { header "__utility/no_destroy.h" }
-    module pair                       { header "__utility/pair.h" }
-    module piecewise_construct        { header "__utility/piecewise_construct.h" }
-    module priority_tag               { header "__utility/priority_tag.h" }
-    module private_constructor_tag    { header "__utility/private_constructor_tag.h" }
-    module rel_ops                    { header "__utility/rel_ops.h" }
-    module small_buffer               { header "__utility/small_buffer.h" }
-    module swap                       { header "__utility/swap.h" }
-    module to_underlying              { header "__utility/to_underlying.h" }
-    module unreachable                { header "__utility/unreachable.h" }
-
-    header "utility"
+  module propagate_const {
+    header "experimental/propagate_const"
     export *
   }
+  module simd {
+    module aligned_tag          { private header "experimental/__simd/aligned_tag.h" }
+    module declaration          { private header "experimental/__simd/declaration.h" }
+    module reference            { private header "experimental/__simd/reference.h" }
+    module scalar               { private header "experimental/__simd/scalar.h" }
+    module simd                 { private header "experimental/__simd/simd.h" }
+    module simd_mask            { private header "experimental/__simd/simd_mask.h" }
+    module traits               { private header "experimental/__simd/traits.h" }
+    module utility              { private header "experimental/__simd/utility.h" }
+    module vec_ext              { private header "experimental/__simd/vec_ext.h" }
 
-  module valarray {
-    header "valarray"
+    header "experimental/simd"
     export *
   }
-
-  module variant {
-    module fwd       { header "__fwd/variant.h" }
-    module monostate { header "__variant/monostate.h" }
-
-    header "variant"
+  module type_traits {
+    header "experimental/type_traits"
     export *
   }
-
-  module vector {
-    module fwd { header "__fwd/vector.h" }
-
-    header "vector"
+  module utility {
+    header "experimental/utility"
     export *
   }
+}
 
-  // Experimental C++ Standard Library interfaces
-  module experimental {
-    module iterator           { header "experimental/iterator" }
-    module memory             { header "experimental/memory" }
-    module propagate_const    { header "experimental/propagate_const" }
-    module type_traits        { header "experimental/type_traits" }
-    module utility            { header "experimental/utility" }
-    module simd {
-      private header "experimental/__simd/aligned_tag.h"
-      private header "experimental/__simd/declaration.h"
-      private header "experimental/__simd/reference.h"
-      private header "experimental/__simd/scalar.h"
-      private header "experimental/__simd/simd_mask.h"
-      private header "experimental/__simd/simd.h"
-      private header "experimental/__simd/traits.h"
-      private header "experimental/__simd/utility.h"
-      private header "experimental/__simd/vec_ext.h"
-      header "experimental/simd"
-      export *
-    }
-  }
-
-  // Implementation detail headers that are private to libc++. These modules
-  // must not be directly imported.
-  module debug_utils {
-    module randomize_range              { header "__debug_utils/randomize_range.h" }
-    module sanitizers                   { header "__debug_utils/sanitizers.h" }
-    module strict_weak_ordering_check   { header "__debug_utils/strict_weak_ordering_check.h" }
-  }
+// Convenience method to get all of the above modules in a single import statement.
+// Importing only the needed modules is likely to be more performant.
+module std [system] {
+  header "__std_clang_module"
+  export *
+}
 
-  module get_fwd {
-    header "__fwd/get.h"
-    export std_core.fwd.pair
-    export std_core.fwd.tuple
-    export std.array.fwd
-    export std.complex.fwd
-    export std.ranges.subrange_fwd
-    export std.variant.fwd
-  }
+// Implementation detail headers that are private to libc++. These modules
+// must not be directly imported.
+module std_private_assert            [system] {
+  header "__assert"
+  export *
+}
+module std_private_bit_reference     [system] {
+  header "__bit_reference"
+  export *
+}
+module std_private_fwd_bit_reference [system] {
+  header "__fwd/bit_reference.h"
+}
+module std_private_fwd_byte [system] {
+  header "__fwd/byte.h"
+}
+module std_private_config            [system] {
+  textual header "__config"
+  textual header "__configuration/abi.h"
+  textual header "__configuration/availability.h"
+  textual header "__configuration/compiler.h"
+  textual header "__configuration/language.h"
+  textual header "__configuration/platform.h"
+  export *
+}
+module std_private_hash_table        [system] {
+  header "__hash_table"
+  export *
+}
+module std_private_locale            [system] {
+  header "__locale"
+  export *
+}
+module std_private_mbstate_t         [system] {
+  header "__mbstate_t.h"
+  export *
+}
+module std_private_node_handle       [system] {
+  header "__node_handle"
+  export *
+}
+module std_private_split_buffer      [system] {
+  header "__split_buffer"
+  export *
+}
+module std_private_std_mbstate_t     [system] {
+  header "__std_mbstate_t.h"
+  export *
+}
+module std_private_tree              [system] {
+  header "__tree"
+  export *
+}
+module std_private_undef_macros      [system] {
+  textual header "__undef_macros"
+  export *
+}
+module std_private_verbose_abort     [system] {
+  header "__verbose_abort"
+  export *
+}
 
-  module pstl {
-    module backend_fwd {
-      header "__pstl/backend_fwd.h"
-    }
-    module backend {
-      header "__pstl/backend.h"
-      export * // need to export everything from whatever backend is currently configured
-    }
-    module backends {
-      module default {
-        header "__pstl/backends/default.h"
-        export std_core.utility_core.empty
-      }
-      module libdispatch {
-        header "__pstl/backends/libdispatch.h"
-        export std.pstl.cpu_algos
-        export std_core.utility_core.empty
-      }
-      module serial {
-        header "__pstl/backends/serial.h"
-        export std_core.utility_core.empty
-      }
-      module std_thread {
-        header "__pstl/backends/std_thread.h"
-        export std.pstl.cpu_algos
-        export std_core.utility_core.empty
-      }
-    }
-    module cpu_algos {
-      module any_of {
-        header "__pstl/cpu_algos/any_of.h"
-      }
-      module cpu_traits {
-        header "__pstl/cpu_algos/cpu_traits.h"
-      }
-      module fill {
-        header "__pstl/cpu_algos/fill.h"
-        export std_core.utility_core.empty
-      }
-      module find_if {
-        header "__pstl/cpu_algos/find_if.h"
-      }
-      module for_each {
-        header "__pstl/cpu_algos/for_each.h"
-        export std_core.utility_core.empty
-      }
-      module merge {
-        header "__pstl/cpu_algos/merge.h"
-      }
-      module stable_sort {
-        header "__pstl/cpu_algos/stable_sort.h"
-        export std_core.utility_core.empty
-      }
-      module transform {
-        header "__pstl/cpu_algos/transform.h"
-      }
-      module transform_reduce {
-        header "__pstl/cpu_algos/transform_reduce.h"
-      }
-    }
-    module dispatch           { header "__pstl/dispatch.h" }
-    module handle_exception   { header "__pstl/handle_exception.h" }
-  }
+module std_private_algorithm_adjacent_find                               [system] { header "__algorithm/adjacent_find.h" }
+module std_private_algorithm_all_of                                      [system] { header "__algorithm/all_of.h" }
+module std_private_algorithm_any_of                                      [system] { header "__algorithm/any_of.h" }
+module std_private_algorithm_binary_search                               [system] { header "__algorithm/binary_search.h" }
+module std_private_algorithm_clamp                                       [system] { header "__algorithm/clamp.h" }
+module std_private_algorithm_comp                                        [system] { header "__algorithm/comp.h" }
+module std_private_algorithm_comp_ref_type                               [system] { header "__algorithm/comp_ref_type.h" }
+module std_private_algorithm_copy                                        [system] {
+  header "__algorithm/copy.h"
+  export std_private_algorithm_copy_move_common
+}
+module std_private_algorithm_copy_backward                               [system] { header "__algorithm/copy_backward.h" }
+module std_private_algorithm_copy_if                                     [system] { header "__algorithm/copy_if.h" }
+module std_private_algorithm_copy_move_common                            [system] {
+  header "__algorithm/copy_move_common.h"
+  export std_private_type_traits_is_trivially_copyable
+}
+module std_private_algorithm_copy_n                                      [system] { header "__algorithm/copy_n.h" }
+module std_private_algorithm_count                                       [system] { header "__algorithm/count.h" }
+module std_private_algorithm_count_if                                    [system] { header "__algorithm/count_if.h" }
+module std_private_algorithm_equal                                       [system] { header "__algorithm/equal.h" }
+module std_private_algorithm_equal_range                                 [system] { header "__algorithm/equal_range.h" }
+module std_private_algorithm_fill                                        [system] { header "__algorithm/fill.h" }
+module std_private_algorithm_fill_n                                      [system] { header "__algorithm/fill_n.h" }
+module std_private_algorithm_find                                        [system] {
+  header "__algorithm/find.h"
+  export std_private_algorithm_unwrap_iter
+}
+module std_private_algorithm_find_end                                    [system] { header "__algorithm/find_end.h" }
+module std_private_algorithm_find_first_of                               [system] { header "__algorithm/find_first_of.h" }
+module std_private_algorithm_find_if                                     [system] { header "__algorithm/find_if.h" }
+module std_private_algorithm_find_if_not                                 [system] { header "__algorithm/find_if_not.h" }
+module std_private_algorithm_find_segment_if                             [system] { header "__algorithm/find_segment_if.h" }
+module std_private_algorithm_fold                                        [system] { header "__algorithm/fold.h" }
+module std_private_algorithm_for_each                                    [system] { header "__algorithm/for_each.h" }
+module std_private_algorithm_for_each_n                                  [system] { header "__algorithm/for_each_n.h" }
+module std_private_algorithm_for_each_segment                            [system] { header "__algorithm/for_each_segment.h" }
+module std_private_algorithm_generate                                    [system] { header "__algorithm/generate.h" }
+module std_private_algorithm_generate_n                                  [system] { header "__algorithm/generate_n.h" }
+module std_private_algorithm_half_positive                               [system] { header "__algorithm/half_positive.h" }
+module std_private_algorithm_in_found_result                             [system] { header "__algorithm/in_found_result.h" }
+module std_private_algorithm_in_fun_result                               [system] { header "__algorithm/in_fun_result.h" }
+module std_private_algorithm_in_in_out_result                            [system] { header "__algorithm/in_in_out_result.h" }
+module std_private_algorithm_in_in_result                                [system] { header "__algorithm/in_in_result.h" }
+module std_private_algorithm_in_out_out_result                           [system] { header "__algorithm/in_out_out_result.h" }
+module std_private_algorithm_in_out_result                               [system] { header "__algorithm/in_out_result.h" }
+module std_private_algorithm_includes                                    [system] { header "__algorithm/includes.h" }
+module std_private_algorithm_inplace_merge                               [system] { header "__algorithm/inplace_merge.h" }
+module std_private_algorithm_is_heap                                     [system] { header "__algorithm/is_heap.h" }
+module std_private_algorithm_is_heap_until                               [system] { header "__algorithm/is_heap_until.h" }
+module std_private_algorithm_is_partitioned                              [system] { header "__algorithm/is_partitioned.h" }
+module std_private_algorithm_is_permutation                              [system] { header "__algorithm/is_permutation.h" }
+module std_private_algorithm_is_sorted                                   [system] { header "__algorithm/is_sorted.h" }
+module std_private_algorithm_is_sorted_until                             [system] { header "__algorithm/is_sorted_until.h" }
+module std_private_algorithm_iter_swap                                   [system] { header "__algorithm/iter_swap.h" }
+module std_private_algorithm_iterator_operations                         [system] {
+  header "__algorithm/iterator_operations.h"
+  export *
+}
+module std_private_algorithm_lexicographical_compare                     [system] { header "__algorithm/lexicographical_compare.h" }
+module std_private_algorithm_lexicographical_compare_three_way           [system] { header "__algorithm/lexicographical_compare_three_way.h" }
+module std_private_algorithm_lower_bound                                 [system] { header "__algorithm/lower_bound.h" }
+module std_private_algorithm_make_heap                                   [system] { header "__algorithm/make_heap.h" }
+module std_private_algorithm_make_projected                              [system] { header "__algorithm/make_projected.h" }
+module std_private_algorithm_max                                         [system] { header "__algorithm/max.h" }
+module std_private_algorithm_max_element                                 [system] { header "__algorithm/max_element.h" }
+module std_private_algorithm_merge                                       [system] { header "__algorithm/merge.h" }
+module std_private_algorithm_min                                         [system] { header "__algorithm/min.h" }
+module std_private_algorithm_min_element                                 [system] { header "__algorithm/min_element.h" }
+module std_private_algorithm_min_max_result                              [system] { header "__algorithm/min_max_result.h" }
+module std_private_algorithm_minmax                                      [system] {
+  header "__algorithm/minmax.h"
+  export *
+}
+module std_private_algorithm_minmax_element                              [system] { header "__algorithm/minmax_element.h" }
+module std_private_algorithm_mismatch                                    [system] {
+  header "__algorithm/mismatch.h"
+  export std_private_algorithm_simd_utils
+  export std_private_iterator_aliasing_iterator
+}
+module std_private_algorithm_move                                        [system] { header "__algorithm/move.h" }
+module std_private_algorithm_move_backward                               [system] { header "__algorithm/move_backward.h" }
+module std_private_algorithm_next_permutation                            [system] { header "__algorithm/next_permutation.h" }
+module std_private_algorithm_none_of                                     [system] { header "__algorithm/none_of.h" }
+module std_private_algorithm_nth_element                                 [system] { header "__algorithm/nth_element.h" }
+module std_private_algorithm_partial_sort                                [system] { header "__algorithm/partial_sort.h" }
+module std_private_algorithm_partial_sort_copy                           [system] { header "__algorithm/partial_sort_copy.h" }
+module std_private_algorithm_partition                                   [system] { header "__algorithm/partition.h" }
+module std_private_algorithm_partition_copy                              [system] { header "__algorithm/partition_copy.h" }
+module std_private_algorithm_partition_point                             [system] { header "__algorithm/partition_point.h" }
+module std_private_algorithm_pop_heap                                    [system] { header "__algorithm/pop_heap.h" }
+module std_private_algorithm_prev_permutation                            [system] { header "__algorithm/prev_permutation.h" }
+module std_private_algorithm_pstl                                        [system] {
+  header "__algorithm/pstl.h"
+  export *
+}
+module std_private_algorithm_push_heap                                   [system] { header "__algorithm/push_heap.h" }
+module std_private_algorithm_ranges_adjacent_find                        [system] { header "__algorithm/ranges_adjacent_find.h" }
+module std_private_algorithm_ranges_all_of                               [system] { header "__algorithm/ranges_all_of.h" }
+module std_private_algorithm_ranges_any_of                               [system] { header "__algorithm/ranges_any_of.h" }
+module std_private_algorithm_ranges_binary_search                        [system] {
+  header "__algorithm/ranges_binary_search.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_clamp                                [system] {
+  header "__algorithm/ranges_clamp.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_contains                             [system] { header "__algorithm/ranges_contains.h" }
+module std_private_algorithm_ranges_contains_subrange                    [system] { header "__algorithm/ranges_contains_subrange.h" }
+module std_private_algorithm_ranges_copy                                 [system] {
+  header "__algorithm/ranges_copy.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_copy_backward                        [system] {
+  header "__algorithm/ranges_copy_backward.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_copy_if                              [system] {
+  header "__algorithm/ranges_copy_if.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_copy_n                               [system] {
+  header "__algorithm/ranges_copy_n.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_count                                [system] { header "__algorithm/ranges_count.h" }
+module std_private_algorithm_ranges_count_if                             [system] { header "__algorithm/ranges_count_if.h" }
+module std_private_algorithm_ranges_ends_with                            [system] { header "__algorithm/ranges_ends_with.h" }
+module std_private_algorithm_ranges_equal                                [system] { header "__algorithm/ranges_equal.h" }
+module std_private_algorithm_ranges_equal_range                          [system] {
+  header "__algorithm/ranges_equal_range.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_fill                                 [system] { header "__algorithm/ranges_fill.h" }
+module std_private_algorithm_ranges_fill_n                               [system] { header "__algorithm/ranges_fill_n.h" }
+module std_private_algorithm_ranges_find                                 [system] { header "__algorithm/ranges_find.h" }
+module std_private_algorithm_ranges_find_end                             [system] { header "__algorithm/ranges_find_end.h" }
+module std_private_algorithm_ranges_find_first_of                        [system] { header "__algorithm/ranges_find_first_of.h" }
+module std_private_algorithm_ranges_find_if                              [system] { header "__algorithm/ranges_find_if.h" }
+module std_private_algorithm_ranges_find_if_not                          [system] { header "__algorithm/ranges_find_if_not.h" }
+module std_private_algorithm_ranges_find_last                            [system] { header "__algorithm/ranges_find_last.h" }
+module std_private_algorithm_ranges_for_each                             [system] {
+  header "__algorithm/ranges_for_each.h"
+  export std_private_algorithm_in_fun_result
+}
+module std_private_algorithm_ranges_for_each_n                           [system] {
+  header "__algorithm/ranges_for_each_n.h"
+  export std_private_algorithm_in_fun_result
+}
+module std_private_algorithm_ranges_generate                             [system] { header "__algorithm/ranges_generate.h" }
+module std_private_algorithm_ranges_generate_n                           [system] { header "__algorithm/ranges_generate_n.h" }
+module std_private_algorithm_ranges_includes                             [system] {
+  header "__algorithm/ranges_includes.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_inplace_merge                        [system] {
+  header "__algorithm/ranges_inplace_merge.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_is_heap                              [system] {
+  header "__algorithm/ranges_is_heap.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_is_heap_until                        [system] {
+  header "__algorithm/ranges_is_heap_until.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_is_partitioned                       [system] { header "__algorithm/ranges_is_partitioned.h" }
+module std_private_algorithm_ranges_is_permutation                       [system] { header "__algorithm/ranges_is_permutation.h" }
+module std_private_algorithm_ranges_is_sorted                            [system] {
+  header "__algorithm/ranges_is_sorted.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_is_sorted_until                      [system] {
+  header "__algorithm/ranges_is_sorted_until.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_iterator_concept                     [system] { header "__algorithm/ranges_iterator_concept.h" }
+module std_private_algorithm_ranges_lexicographical_compare              [system] {
+  header "__algorithm/ranges_lexicographical_compare.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_lower_bound                          [system] {
+  header "__algorithm/ranges_lower_bound.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_make_heap                            [system] {
+  header "__algorithm/ranges_make_heap.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_max                                  [system] {
+  header "__algorithm/ranges_max.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_max_element                          [system] {
+  header "__algorithm/ranges_max_element.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_merge                                [system] {
+  header "__algorithm/ranges_merge.h"
+  export std_private_algorithm_in_in_out_result
+}
+module std_private_algorithm_ranges_min                                  [system] {
+  header "__algorithm/ranges_min.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_min_element                          [system] {
+  header "__algorithm/ranges_min_element.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_minmax                               [system] {
+  header "__algorithm/ranges_minmax.h"
+  export std_private_functional_ranges_operations
+  export std_private_algorithm_min_max_result
+}
+module std_private_algorithm_ranges_minmax_element                       [system] {
+  header "__algorithm/ranges_minmax_element.h"
+  export std_private_functional_ranges_operations
+  export std_private_algorithm_min_max_result
+}
+module std_private_algorithm_ranges_mismatch                             [system] {
+  header "__algorithm/ranges_mismatch.h"
+  export std_private_algorithm_in_in_result
+}
+module std_private_algorithm_ranges_move                                 [system] {
+  header "__algorithm/ranges_move.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_move_backward                        [system] {
+  header "__algorithm/ranges_move_backward.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_next_permutation                     [system] {
+  header "__algorithm/ranges_next_permutation.h"
+  export std_private_algorithm_in_found_result
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_none_of                              [system] { header "__algorithm/ranges_none_of.h" }
+module std_private_algorithm_ranges_nth_element                          [system] {
+  header "__algorithm/ranges_nth_element.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_partial_sort                         [system] {
+  header "__algorithm/ranges_partial_sort.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_partial_sort_copy                    [system] {
+  header "__algorithm/ranges_partial_sort_copy.h"
+  export std_private_algorithm_in_out_result
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_partition                            [system] { header "__algorithm/ranges_partition.h" }
+module std_private_algorithm_ranges_partition_copy                       [system] { header "__algorithm/ranges_partition_copy.h" }
+module std_private_algorithm_ranges_partition_point                      [system] { header "__algorithm/ranges_partition_point.h" }
+module std_private_algorithm_ranges_pop_heap                             [system] {
+  header "__algorithm/ranges_pop_heap.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_prev_permutation                     [system] {
+  header "__algorithm/ranges_prev_permutation.h"
+  export std_private_algorithm_in_found_result
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_push_heap                            [system] {
+  header "__algorithm/ranges_push_heap.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_remove                               [system] { header "__algorithm/ranges_remove.h" }
+module std_private_algorithm_ranges_remove_copy                          [system] {
+  header "__algorithm/ranges_remove_copy.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_remove_copy_if                       [system] {
+  header "__algorithm/ranges_remove_copy_if.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_remove_if                            [system] { header "__algorithm/ranges_remove_if.h" }
+module std_private_algorithm_ranges_replace                              [system] { header "__algorithm/ranges_replace.h" }
+module std_private_algorithm_ranges_replace_copy                         [system] {
+  header "__algorithm/ranges_replace_copy.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_replace_copy_if                      [system] {
+  header "__algorithm/ranges_replace_copy_if.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_replace_if                           [system] { header "__algorithm/ranges_replace_if.h" }
+module std_private_algorithm_ranges_reverse                              [system] { header "__algorithm/ranges_reverse.h" }
+module std_private_algorithm_ranges_reverse_copy                         [system] {
+  header "__algorithm/ranges_reverse_copy.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_rotate                               [system] { header "__algorithm/ranges_rotate.h" }
+module std_private_algorithm_ranges_rotate_copy                          [system] {
+  header "__algorithm/ranges_rotate_copy.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_sample                               [system] { header "__algorithm/ranges_sample.h" }
+module std_private_algorithm_ranges_search                               [system] { header "__algorithm/ranges_search.h" }
+module std_private_algorithm_ranges_search_n                             [system] { header "__algorithm/ranges_search_n.h" }
+module std_private_algorithm_ranges_set_difference                       [system] {
+  header "__algorithm/ranges_set_difference.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_set_intersection                     [system] {
+  header "__algorithm/ranges_set_intersection.h"
+  export std_private_algorithm_in_in_out_result
+}
+module std_private_algorithm_ranges_set_symmetric_difference             [system] {
+  header "__algorithm/ranges_set_symmetric_difference.h"
+  export std_private_algorithm_in_in_out_result
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_set_union                            [system] {
+  header "__algorithm/ranges_set_union.h"
+  export std_private_algorithm_in_in_out_result
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_shuffle                              [system] { header "__algorithm/ranges_shuffle.h" }
+module std_private_algorithm_ranges_sort                                 [system] {
+  header "__algorithm/ranges_sort.h"
+  export std_private_algorithm_make_projected
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_sort_heap                            [system] {
+  header "__algorithm/ranges_sort_heap.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_stable_partition                     [system] { header "__algorithm/ranges_stable_partition.h" }
+module std_private_algorithm_ranges_stable_sort                          [system] {
+  header "__algorithm/ranges_stable_sort.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_ranges_starts_with                          [system] { header "__algorithm/ranges_starts_with.h" }
+module std_private_algorithm_ranges_swap_ranges                          [system] {
+  header "__algorithm/ranges_swap_ranges.h"
+  export std_private_algorithm_in_in_result
+}
+module std_private_algorithm_ranges_transform                            [system] {
+  header "__algorithm/ranges_transform.h"
+  export std_private_algorithm_in_in_out_result
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_unique                               [system] { header "__algorithm/ranges_unique.h" }
+module std_private_algorithm_ranges_unique_copy                          [system] {
+  header "__algorithm/ranges_unique_copy.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_algorithm_ranges_upper_bound                          [system] {
+  header "__algorithm/ranges_upper_bound.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_algorithm_remove                                      [system] { header "__algorithm/remove.h" }
+module std_private_algorithm_remove_copy                                 [system] { header "__algorithm/remove_copy.h" }
+module std_private_algorithm_remove_copy_if                              [system] { header "__algorithm/remove_copy_if.h" }
+module std_private_algorithm_remove_if                                   [system] { header "__algorithm/remove_if.h" }
+module std_private_algorithm_replace                                     [system] { header "__algorithm/replace.h" }
+module std_private_algorithm_replace_copy                                [system] { header "__algorithm/replace_copy.h" }
+module std_private_algorithm_replace_copy_if                             [system] { header "__algorithm/replace_copy_if.h" }
+module std_private_algorithm_replace_if                                  [system] { header "__algorithm/replace_if.h" }
+module std_private_algorithm_reverse                                     [system] { header "__algorithm/reverse.h" }
+module std_private_algorithm_reverse_copy                                [system] { header "__algorithm/reverse_copy.h" }
+module std_private_algorithm_rotate                                      [system] { header "__algorithm/rotate.h" }
+module std_private_algorithm_rotate_copy                                 [system] { header "__algorithm/rotate_copy.h" }
+module std_private_algorithm_sample                                      [system] { header "__algorithm/sample.h" }
+module std_private_algorithm_search                                      [system] { header "__algorithm/search.h" }
+module std_private_algorithm_search_n                                    [system] { header "__algorithm/search_n.h" }
+module std_private_algorithm_set_difference                              [system] { header "__algorithm/set_difference.h" }
+module std_private_algorithm_set_intersection                            [system] { header "__algorithm/set_intersection.h" }
+module std_private_algorithm_set_symmetric_difference                    [system] { header "__algorithm/set_symmetric_difference.h" }
+module std_private_algorithm_set_union                                   [system] { header "__algorithm/set_union.h" }
+module std_private_algorithm_shift_left                                  [system] { header "__algorithm/shift_left.h" }
+module std_private_algorithm_shift_right                                 [system] { header "__algorithm/shift_right.h" }
+module std_private_algorithm_shuffle                                     [system] { header "__algorithm/shuffle.h" }
+module std_private_algorithm_sift_down                                   [system] { header "__algorithm/sift_down.h" }
+module std_private_algorithm_sort                                        [system] {
+  header "__algorithm/sort.h"
+  export std_private_debug_utils_strict_weak_ordering_check
+}
+module std_private_algorithm_simd_utils                                  [system] { header "__algorithm/simd_utils.h" }
+module std_private_algorithm_sort_heap                                   [system] { header "__algorithm/sort_heap.h" }
+module std_private_algorithm_stable_partition                            [system] { header "__algorithm/stable_partition.h" }
+module std_private_algorithm_stable_sort                                 [system] { header "__algorithm/stable_sort.h" }
+module std_private_algorithm_swap_ranges                                 [system] {
+  header "__algorithm/swap_ranges.h"
+  export std_private_algorithm_iterator_operations
+}
+module std_private_algorithm_three_way_comp_ref_type                     [system] { header "__algorithm/three_way_comp_ref_type.h" }
+module std_private_algorithm_transform                                   [system] { header "__algorithm/transform.h" }
+module std_private_algorithm_uniform_random_bit_generator_adaptor        [system] { header "__algorithm/uniform_random_bit_generator_adaptor.h" }
+module std_private_algorithm_unique                                      [system] { header "__algorithm/unique.h" }
+module std_private_algorithm_unique_copy                                 [system] { header "__algorithm/unique_copy.h" }
+module std_private_algorithm_unwrap_iter                                 [system] {
+  header "__algorithm/unwrap_iter.h"
+  export std_private_iterator_iterator_traits
+}
+module std_private_algorithm_unwrap_range                                [system] {
+  header "__algorithm/unwrap_range.h"
+  export std_private_utility_pair
+}
+module std_private_algorithm_upper_bound                                 [system] { header "__algorithm/upper_bound.h" }
 
-  // Miscellaneous modules for top-level headers
-  module bit_reference_fwd {
-    header "__fwd/bit_reference.h"
-  }
-  module bit_reference {
-    header "__bit_reference"
-    export std.bit_reference_fwd
-  }
-  module hash_table           { header "__hash_table" }
-  module node_handle          { header "__node_handle" }
-  module split_buffer         { header "__split_buffer" }
-  module tree                 { header "__tree" }
-  module std_mbstate_t {
-    header "__std_mbstate_t.h"
-    export *
-  }
-  module verbose_abort {
-    header "__verbose_abort"
-  }
-  module internal_assert {
-    header "__assert"
-    export *
-  }
+module std_private_array_array_fwd [system] { header "__fwd/array.h" }
 
-  module undef_macros {
-    textual header "__undef_macros"
-  }
+module std_private_atomic_aliases             [system] {
+  header "__atomic/aliases.h"
+  export std_private_atomic_atomic
+}
+module std_private_atomic_atomic              [system] {
+  header "__atomic/atomic.h"
+  export std_private_atomic_atomic_base
+}
+module std_private_atomic_atomic_base         [system] { header "__atomic/atomic_base.h" }
+module std_private_atomic_atomic_flag         [system] {
+  header "__atomic/atomic_flag.h"
+  export *
+}
+module std_private_atomic_atomic_init         [system] { header "__atomic/atomic_init.h" }
+module std_private_atomic_atomic_lock_free    [system] { header "__atomic/atomic_lock_free.h" }
+module std_private_atomic_atomic_ref          [system] { header "__atomic/atomic_ref.h" }
+module std_private_atomic_atomic_sync         [system] {
+  header "__atomic/atomic_sync.h"
+  export std_private_atomic_to_gcc_order
+}
+module std_private_atomic_check_memory_order  [system] { header "__atomic/check_memory_order.h" }
+module std_private_atomic_contention_t        [system] { header "__atomic/contention_t.h" }
+module std_private_atomic_cxx_atomic_impl     [system] { header "__atomic/cxx_atomic_impl.h" }
+module std_private_atomic_fence               [system] { header "__atomic/fence.h" }
+module std_private_atomic_is_always_lock_free [system] { header "__atomic/is_always_lock_free.h" }
+module std_private_atomic_kill_dependency     [system] { header "__atomic/kill_dependency.h" }
+module std_private_atomic_memory_order        [system] { header "__atomic/memory_order.h" }
+module std_private_atomic_to_gcc_order        [system] {
+  header "__atomic/to_gcc_order.h"
+  export std_private_atomic_memory_order
+}
 
-  // This module needs to appear after __tree to work around issues with modules in Objective-C++ mode.
-  module coroutine {
-    module coroutine_handle         { header "__coroutine/coroutine_handle.h" }
-    module coroutine_traits         { header "__coroutine/coroutine_traits.h" }
-    module noop_coroutine_handle    { header "__coroutine/noop_coroutine_handle.h" }
-    module trivial_awaitables       { header "__coroutine/trivial_awaitables.h" }
+module std_private_bit_bit_cast       [system] { header "__bit/bit_cast.h" }
+module std_private_bit_bit_ceil       [system] { header "__bit/bit_ceil.h" }
+module std_private_bit_bit_floor      [system] { header "__bit/bit_floor.h" }
+module std_private_bit_bit_log2       [system] { header "__bit/bit_log2.h" }
+module std_private_bit_bit_width      [system] { header "__bit/bit_width.h" }
+module std_private_bit_blsr           [system] { header "__bit/blsr.h" }
+module std_private_bit_byteswap       [system] { header "__bit/byteswap.h" }
+module std_private_bit_countl         [system] { header "__bit/countl.h" }
+module std_private_bit_countr         [system] { header "__bit/countr.h" }
+module std_private_bit_endian         [system] { header "__bit/endian.h" }
+module std_private_bit_has_single_bit [system] { header "__bit/has_single_bit.h" }
+module std_private_bit_invert_if      [system] { header "__bit/invert_if.h" }
+module std_private_bit_popcount       [system] { header "__bit/popcount.h" }
+module std_private_bit_rotate         [system] { header "__bit/rotate.h" }
+
+module std_private_chrono_calendar               [system] { header "__chrono/calendar.h" }
+module std_private_chrono_concepts               [system] { header "__chrono/concepts.h" }
+module std_private_chrono_convert_to_timespec    [system] { header "__chrono/convert_to_timespec.h" }
+module std_private_chrono_convert_to_tm          [system] { header "__chrono/convert_to_tm.h" }
+module std_private_chrono_day                    [system] { header "__chrono/day.h" }
+module std_private_chrono_duration               [system] {
+  header "__chrono/duration.h"
+  export std_private_type_traits_is_convertible
+}
+module std_private_chrono_exception              [system] { header "__chrono/exception.h" }
+module std_private_chrono_file_clock             [system] { header "__chrono/file_clock.h" }
+module std_private_chrono_formatter              [system] {
+  header "__chrono/formatter.h"
+}
+module std_private_chrono_hh_mm_ss               [system] { header "__chrono/hh_mm_ss.h" }
+module std_private_chrono_high_resolution_clock  [system] {
+  header "__chrono/high_resolution_clock.h"
+  export std_private_chrono_steady_clock
+  export std_private_chrono_system_clock
+}
+module std_private_chrono_leap_second            [system] { header "__chrono/leap_second.h" }
+module std_private_chrono_literals               [system] { header "__chrono/literals.h" }
+module std_private_chrono_local_info             [system] {
+  header "__chrono/local_info.h"
+  export std_private_chrono_sys_info
+}
+module std_private_chrono_month                  [system] { header "__chrono/month.h" }
+module std_private_chrono_month_weekday          [system] { header "__chrono/month_weekday.h" }
+module std_private_chrono_monthday               [system] { header "__chrono/monthday.h" }
+module std_private_chrono_ostream                [system] {
+  header "__chrono/ostream.h"
+}
+module std_private_chrono_parser_std_format_spec [system] {
+  header "__chrono/parser_std_format_spec.h"
+}
+module std_private_chrono_statically_widen       [system] { header "__chrono/statically_widen.h" }
+module std_private_chrono_steady_clock           [system] {
+  header "__chrono/steady_clock.h"
+  export std_private_chrono_time_point
+}
+module std_private_chrono_time_zone              [system] {
+  header "__chrono/time_zone.h"
+  export std_private_memory_unique_ptr
+}
+module std_private_chrono_time_zone_link         [system] {
+  header "__chrono/time_zone_link.h"
+}
+module std_private_chrono_sys_info               [system] {
+  header "__chrono/sys_info.h"
+}
+module std_private_chrono_system_clock           [system] {
+  header "__chrono/system_clock.h"
+  export std_private_chrono_time_point
+}
+module std_private_chrono_tzdb                   [system] {
+  header "__chrono/tzdb.h"
+  export *
+}
+module std_private_chrono_tzdb_list              [system] {
+  header "__chrono/tzdb_list.h"
+  export *
+}
+module std_private_chrono_time_point             [system] { header "__chrono/time_point.h" }
+module std_private_chrono_weekday                [system] { header "__chrono/weekday.h" }
+module std_private_chrono_year                   [system] { header "__chrono/year.h" }
+module std_private_chrono_year_month             [system] { header "__chrono/year_month.h" }
+module std_private_chrono_year_month_day         [system] { header "__chrono/year_month_day.h" }
+module std_private_chrono_year_month_weekday     [system] { header "__chrono/year_month_weekday.h" }
+module std_private_chrono_zoned_time             [system] { header "__chrono/zoned_time.h" }
+
+module std_private_compare_common_comparison_category     [system] { header "__compare/common_comparison_category.h" }
+module std_private_compare_compare_partial_order_fallback [system] { header "__compare/compare_partial_order_fallback.h" }
+module std_private_compare_compare_strong_order_fallback  [system] { header "__compare/compare_strong_order_fallback.h" }
+module std_private_compare_compare_three_way              [system] { header "__compare/compare_three_way.h" }
+module std_private_compare_compare_three_way_result       [system] { header "__compare/compare_three_way_result.h" }
+module std_private_compare_compare_weak_order_fallback    [system] { header "__compare/compare_weak_order_fallback.h" }
+module std_private_compare_is_eq                          [system] { header "__compare/is_eq.h" }
+module std_private_compare_ordering                       [system] { header "__compare/ordering.h" }
+module std_private_compare_partial_order                  [system] { header "__compare/partial_order.h" }
+module std_private_compare_strong_order                   [system] { header "__compare/strong_order.h" }
+module std_private_compare_synth_three_way                [system] { header "__compare/synth_three_way.h" }
+module std_private_compare_three_way_comparable           [system] { header "__compare/three_way_comparable.h" }
+module std_private_compare_weak_order                     [system] { header "__compare/weak_order.h" }
+
+module std_private_complex_complex_fwd            [system] { header "__fwd/complex.h" }
+
+module std_private_concepts_arithmetic            [system] { header "__concepts/arithmetic.h" }
+module std_private_concepts_assignable            [system] { header "__concepts/assignable.h" }
+module std_private_concepts_boolean_testable      [system] { header "__concepts/boolean_testable.h" }
+module std_private_concepts_class_or_enum         [system] { header "__concepts/class_or_enum.h" }
+module std_private_concepts_common_reference_with [system] { header "__concepts/common_reference_with.h" }
+module std_private_concepts_common_with           [system] { header "__concepts/common_with.h" }
+module std_private_concepts_constructible         [system] {
+  header "__concepts/constructible.h"
+  export std_private_concepts_destructible
+}
+module std_private_concepts_convertible_to        [system] { header "__concepts/convertible_to.h" }
+module std_private_concepts_copyable              [system] { header "__concepts/copyable.h" }
+module std_private_concepts_derived_from          [system] { header "__concepts/derived_from.h" }
+module std_private_concepts_destructible          [system] {
+  header "__concepts/destructible.h"
+  export std_private_type_traits_is_nothrow_destructible
+}
+module std_private_concepts_different_from        [system] { header "__concepts/different_from.h" }
+module std_private_concepts_equality_comparable   [system] {
+  header "__concepts/equality_comparable.h"
+  export std_private_type_traits_common_reference
+}
+module std_private_concepts_invocable             [system] { header "__concepts/invocable.h" }
+module std_private_concepts_movable               [system] {
+  header "__concepts/movable.h"
+  export std_private_type_traits_is_object
+}
+module std_private_concepts_predicate             [system] { header "__concepts/predicate.h" }
+module std_private_concepts_regular               [system] { header "__concepts/regular.h" }
+module std_private_concepts_relation              [system] { header "__concepts/relation.h" }
+module std_private_concepts_same_as               [system] {
+  header "__concepts/same_as.h"
+  export std_private_type_traits_is_same
+}
+module std_private_concepts_semiregular           [system] { header "__concepts/semiregular.h" }
+module std_private_concepts_swappable             [system] { header "__concepts/swappable.h" }
+module std_private_concepts_totally_ordered       [system] { header "__concepts/totally_ordered.h" }
+
+module std_private_debug_utils_randomize_range            [system] { header "__debug_utils/randomize_range.h" }
+module std_private_debug_utils_sanitizers                 [system] { header "__debug_utils/sanitizers.h" }
+module std_private_debug_utils_strict_weak_ordering_check [system] {
+  header "__debug_utils/strict_weak_ordering_check.h"
+  export std_private_type_traits_is_constant_evaluated
+}
 
-    header "coroutine"
-    export *
-  }
-} // module std
+module std_private_deque_fwd [system] { header "__fwd/deque.h" }
 
-// C compatibility headers
-//
-// These modules need to be their own top-level modules because they depend on the system-provided
-// headers (via include_next), which are then free to include other C headers provided by libc++.
-// If we group these headers in a single module, we would end up with circular dependencies.
-module std_complex_h [system] {
-  header "complex.h"
-  export *
+module std_private_exception_exception        [system] { header "__exception/exception.h" }
+module std_private_exception_exception_ptr    [system] {
+  header "__exception/exception_ptr.h"
+  export std_private_exception_operations
 }
-module std_ctype_h [system] {
-  header "ctype.h"
+module std_private_exception_nested_exception [system] { header "__exception/nested_exception.h" }
+module std_private_exception_operations       [system] { header "__exception/operations.h" }
+module std_private_exception_terminate        [system] { header "__exception/terminate.h" }
+
+module std_private_expected_bad_expected_access [system] { header "__expected/bad_expected_access.h" }
+module std_private_expected_expected            [system] { header "__expected/expected.h" }
+module std_private_expected_unexpect            [system] { header "__expected/unexpect.h" }
+module std_private_expected_unexpected          [system] { header "__expected/unexpected.h" }
+
+module std_private_format_buffer                          [system] { header "__format/buffer.h" }
+module std_private_format_concepts                        [system] { header "__format/concepts.h" }
+module std_private_format_container_adaptor               [system] { header "__format/container_adaptor.h" }
+module std_private_format_enable_insertable               [system] { header "__format/enable_insertable.h" }
+module std_private_format_escaped_output_table            [system] { header "__format/escaped_output_table.h" }
+module std_private_format_extended_grapheme_cluster_table [system] { header "__format/extended_grapheme_cluster_table.h" }
+module std_private_format_format_arg                      [system] { header "__format/format_arg.h" }
+module std_private_format_format_arg_store                [system] { header "__format/format_arg_store.h" }
+module std_private_format_format_args                     [system] { header "__format/format_args.h" }
+module std_private_format_format_context                  [system] {
+  header "__format/format_context.h"
   export *
 }
-module std_errno_h [system] {
-  header "errno.h"
+module std_private_format_format_error                    [system] { header "__format/format_error.h" }
+module std_private_format_format_functions                [system] {
+  header "__format/format_functions.h"
+  export std_string
+}
+module std_private_format_fwd                             [system] { header "__fwd/format.h" }
+module std_private_format_format_parse_context            [system] { header "__format/format_parse_context.h" }
+module std_private_format_format_string                   [system] { header "__format/format_string.h" }
+module std_private_format_format_to_n_result              [system] {
+  header "__format/format_to_n_result.h"
+  export std_private_iterator_incrementable_traits
+}
+module std_private_format_formatter                       [system] { header "__format/formatter.h" }
+module std_private_format_formatter_bool                  [system] { header "__format/formatter_bool.h" }
+module std_private_format_formatter_char                  [system] { header "__format/formatter_char.h" }
+module std_private_format_formatter_floating_point        [system] { header "__format/formatter_floating_point.h" }
+module std_private_format_formatter_integer               [system] { header "__format/formatter_integer.h" }
+module std_private_format_formatter_integral              [system] { header "__format/formatter_integral.h" }
+module std_private_format_formatter_output                [system] { header "__format/formatter_output.h" }
+module std_private_format_formatter_pointer               [system] { header "__format/formatter_pointer.h" }
+module std_private_format_formatter_string                [system] { header "__format/formatter_string.h" }
+module std_private_format_formatter_tuple                 [system] { header "__format/formatter_tuple.h" }
+module std_private_format_indic_conjunct_break_table      [system] { header "__format/indic_conjunct_break_table.h" }
+module std_private_format_parser_std_format_spec          [system] { header "__format/parser_std_format_spec.h" }
+module std_private_format_range_default_formatter         [system] { header "__format/range_default_formatter.h" }
+module std_private_format_range_formatter                 [system] { header "__format/range_formatter.h" }
+module std_private_format_unicode                         [system] {
+  header "__format/unicode.h"
+  export std_private_format_extended_grapheme_cluster_table
+  export std_private_format_indic_conjunct_break_table
+}
+module std_private_format_width_estimation_table          [system] { header "__format/width_estimation_table.h" }
+module std_private_format_write_escaped                   [system] { header "__format/write_escaped.h" }
+
+module std_private_functional_binary_function            [system] { header "__functional/binary_function.h" }
+module std_private_functional_binary_negate              [system] { header "__functional/binary_negate.h" }
+module std_private_functional_bind                       [system] { header "__functional/bind.h" }
+module std_private_functional_bind_back                  [system] { header "__functional/bind_back.h" }
+module std_private_functional_bind_front                 [system] { header "__functional/bind_front.h" }
+module std_private_functional_binder1st                  [system] { header "__functional/binder1st.h" }
+module std_private_functional_binder2nd                  [system] { header "__functional/binder2nd.h" }
+module std_private_functional_boyer_moore_searcher       [system] {
+  header "__functional/boyer_moore_searcher.h"
+  export std_private_memory_shared_ptr
+}
+module std_private_functional_compose                    [system] {
+  header "__functional/compose.h"
+  export std_private_functional_perfect_forward
+}
+module std_private_functional_default_searcher           [system] { header "__functional/default_searcher.h" }
+module std_private_functional_function                   [system] { header "__functional/function.h" }
+module std_private_functional_hash                       [system] {
+  header "__functional/hash.h"
+  export std_cstdint
+  export std_private_type_traits_underlying_type
+  export std_private_utility_pair
+}
+module std_private_functional_fwd                        [system] { header "__fwd/functional.h" }
+module std_private_functional_identity                   [system] { header "__functional/identity.h" }
+module std_private_functional_invoke                     [system] {
+  header "__functional/invoke.h"
   export *
 }
-module std_fenv_h [system] {
-  header "fenv.h"
+module std_private_functional_is_transparent             [system] { header "__functional/is_transparent.h" }
+module std_private_functional_mem_fn                     [system] { header "__functional/mem_fn.h" }
+module std_private_functional_mem_fun_ref                [system] { header "__functional/mem_fun_ref.h" }
+module std_private_functional_not_fn                     [system] {
+  header "__functional/not_fn.h"
+  export std_private_functional_perfect_forward
+}
+module std_private_functional_operations                 [system] { header "__functional/operations.h" }
+module std_private_functional_perfect_forward            [system] {
+  header "__functional/perfect_forward.h"
   export *
 }
-module std_float_h [system] {
-  header "float.h"
+module std_private_functional_pointer_to_binary_function [system] { header "__functional/pointer_to_binary_function.h" }
+module std_private_functional_pointer_to_unary_function  [system] { header "__functional/pointer_to_unary_function.h" }
+module std_private_functional_ranges_operations          [system] { header "__functional/ranges_operations.h" }
+module std_private_functional_reference_wrapper          [system] { header "__functional/reference_wrapper.h" }
+module std_private_functional_unary_function             [system] { header "__functional/unary_function.h" }
+module std_private_functional_unary_negate               [system] { header "__functional/unary_negate.h" }
+module std_private_functional_weak_result_type           [system] { header "__functional/weak_result_type.h" }
+
+module std_private_ios_fpos [system] { header "__ios/fpos.h" }
+
+module std_private_iosfwd_fstream_fwd   [system] { header "__fwd/fstream.h" }
+module std_private_iosfwd_ios_fwd       [system] { header "__fwd/ios.h" }
+module std_private_iosfwd_istream_fwd   [system] { header "__fwd/istream.h" }
+module std_private_iosfwd_ostream_fwd   [system] { header "__fwd/ostream.h" }
+module std_private_iosfwd_sstream_fwd   [system] { header "__fwd/sstream.h" }
+module std_private_iosfwd_streambuf_fwd [system] { header "__fwd/streambuf.h" }
+
+module std_private_iterator_access                  [system] { header "__iterator/access.h" }
+module std_private_iterator_advance                 [system] { header "__iterator/advance.h" }
+module std_private_iterator_aliasing_iterator       [system] { header "__iterator/aliasing_iterator.h" }
+module std_private_iterator_back_insert_iterator    [system] { header "__iterator/back_insert_iterator.h" }
+module std_private_iterator_bounded_iter            [system] { header "__iterator/bounded_iter.h" }
+module std_private_iterator_common_iterator         [system] { header "__iterator/common_iterator.h" }
+module std_private_iterator_concepts                [system] {
+  header "__iterator/concepts.h"
+  export std_private_concepts_constructible
+  export std_private_concepts_equality_comparable
+  export std_private_concepts_movable
+  export std_private_type_traits_common_reference
+  export std_private_type_traits_is_reference
+  export std_private_type_traits_remove_cvref
+}
+module std_private_iterator_counted_iterator        [system] { header "__iterator/counted_iterator.h" }
+module std_private_iterator_cpp17_iterator_concepts [system] { header "__iterator/cpp17_iterator_concepts.h" }
+module std_private_iterator_data                    [system] { header "__iterator/data.h" }
+module std_private_iterator_default_sentinel        [system] { header "__iterator/default_sentinel.h" }
+module std_private_iterator_distance                [system] {
+  header "__iterator/distance.h"
+  export std_private_ranges_size
+}
+module std_private_iterator_empty                   [system] { header "__iterator/empty.h" }
+module std_private_iterator_erase_if_container      [system] { header "__iterator/erase_if_container.h" }
+module std_private_iterator_front_insert_iterator   [system] { header "__iterator/front_insert_iterator.h" }
+module std_private_iterator_incrementable_traits    [system] { header "__iterator/incrementable_traits.h" }
+module std_private_iterator_indirectly_comparable   [system] { header "__iterator/indirectly_comparable.h" }
+module std_private_iterator_insert_iterator         [system] { header "__iterator/insert_iterator.h" }
+module std_private_iterator_istream_iterator        [system] { header "__iterator/istream_iterator.h" }
+module std_private_iterator_istreambuf_iterator     [system] { header "__iterator/istreambuf_iterator.h" }
+module std_private_iterator_iter_move               [system] { header "__iterator/iter_move.h" }
+module std_private_iterator_iter_swap               [system] { header "__iterator/iter_swap.h" }
+module std_private_iterator_iterator                [system] { header "__iterator/iterator.h" }
+module std_private_iterator_iterator_traits         [system] {
+  header "__iterator/iterator_traits.h"
+  export std_private_type_traits_is_primary_template
+  export std_private_type_traits_integral_constant
+}
+module std_private_iterator_iterator_with_data      [system] { header "__iterator/iterator_with_data.h" }
+module std_private_iterator_mergeable               [system] {
+  header "__iterator/mergeable.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_iterator_move_iterator           [system] { header "__iterator/move_iterator.h" }
+module std_private_iterator_move_sentinel           [system] { header "__iterator/move_sentinel.h" }
+module std_private_iterator_next                    [system] { header "__iterator/next.h" }
+module std_private_iterator_ostream_iterator        [system] { header "__iterator/ostream_iterator.h" }
+module std_private_iterator_ostreambuf_iterator     [system] {
+  header "__iterator/ostreambuf_iterator.h"
   export *
 }
-module std_inttypes_h [system] {
-  header "inttypes.h"
+module std_private_iterator_permutable              [system] { header "__iterator/permutable.h" }
+module std_private_iterator_prev                    [system] { header "__iterator/prev.h" }
+module std_private_iterator_projected               [system] { header "__iterator/projected.h" }
+module std_private_iterator_ranges_iterator_traits  [system] { header "__iterator/ranges_iterator_traits.h" }
+module std_private_iterator_readable_traits         [system] { header "__iterator/readable_traits.h" }
+module std_private_iterator_reverse_access          [system] { header "__iterator/reverse_access.h" }
+module std_private_iterator_reverse_iterator        [system] { header "__iterator/reverse_iterator.h" }
+module std_private_iterator_segmented_iterator      [system] { header "__iterator/segmented_iterator.h" }
+module std_private_iterator_size                    [system] { header "__iterator/size.h" }
+module std_private_iterator_sortable                [system] {
+  header "__iterator/sortable.h"
+  export std_private_functional_ranges_operations
+}
+module std_private_iterator_unreachable_sentinel    [system] { header "__iterator/unreachable_sentinel.h" }
+module std_private_iterator_wrap_iter               [system] { header "__iterator/wrap_iter.h" }
+
+module std_private_locale_locale_base_api_android              [system] { textual header "__locale_dir/locale_base_api/android.h" }
+module std_private_locale_locale_base_api_bsd_locale_defaults  [system] { textual header "__locale_dir/locale_base_api/bsd_locale_defaults.h" }
+module std_private_locale_locale_base_api_bsd_locale_fallbacks [system] { textual header "__locale_dir/locale_base_api/bsd_locale_fallbacks.h" }
+module std_private_locale_locale_base_api_fuchsia              [system] { textual header "__locale_dir/locale_base_api/fuchsia.h" }
+module std_private_locale_locale_base_api_ibm                  [system] { textual header "__locale_dir/locale_base_api/ibm.h" }
+module std_private_locale_locale_base_api_locale_guard         [system] { header "__locale_dir/locale_base_api/locale_guard.h" }
+module std_private_locale_locale_base_api_musl                 [system] { textual header "__locale_dir/locale_base_api/musl.h" }
+module std_private_locale_locale_base_api_newlib               [system] { textual header "__locale_dir/locale_base_api/newlib.h" }
+module std_private_locale_locale_base_api_openbsd              [system] { textual header "__locale_dir/locale_base_api/openbsd.h" }
+module std_private_locale_locale_base_api_win32                [system] { textual header "__locale_dir/locale_base_api/win32.h" }
+module std_private_locale_locale_base_api                      [system] {
+  header "__locale_dir/locale_base_api.h"
   export *
 }
-module std_locale_h [system] {
-  header "locale.h"
+
+module std_private_math_abs                             [system] { header "__math/abs.h" }
+module std_private_math_copysign                        [system] { header "__math/copysign.h" }
+module std_private_math_error_functions                 [system] { header "__math/error_functions.h" }
+module std_private_math_exponential_functions           [system] { header "__math/exponential_functions.h" }
+module std_private_math_fdim                            [system] { header "__math/fdim.h" }
+module std_private_math_fma                             [system] { header "__math/fma.h" }
+module std_private_math_gamma                           [system] { header "__math/gamma.h" }
+module std_private_math_hyperbolic_functions            [system] { header "__math/hyperbolic_functions.h" }
+module std_private_math_hypot                           [system] { header "__math/hypot.h" }
+module std_private_math_inverse_hyperbolic_functions    [system] { header "__math/inverse_hyperbolic_functions.h" }
+module std_private_math_inverse_trigonometric_functions [system] { header "__math/inverse_trigonometric_functions.h" }
+module std_private_math_logarithms                      [system] { header "__math/logarithms.h" }
+module std_private_math_min_max                         [system] { header "__math/min_max.h" }
+module std_private_math_modulo                          [system] { header "__math/modulo.h" }
+module std_private_math_remainder                       [system] { header "__math/remainder.h" }
+module std_private_math_roots                           [system] { header "__math/roots.h" }
+module std_private_math_rounding_functions              [system] { header "__math/rounding_functions.h" }
+module std_private_math_special_functions               [system] { header "__math/special_functions.h" }
+module std_private_math_traits                          [system] { header "__math/traits.h" }
+module std_private_math_trigonometric_functions         [system] { header "__math/trigonometric_functions.h" }
+
+module std_private_memory_addressof                       [system] { header "__memory/addressof.h" }
+module std_private_memory_align                           [system] { header "__memory/align.h" }
+module std_private_memory_aligned_alloc                   [system] { header "__memory/aligned_alloc.h" }
+module std_private_memory_allocate_at_least               [system] { header "__memory/allocate_at_least.h" }
+module std_private_memory_allocation_guard                [system] { header "__memory/allocation_guard.h" }
+module std_private_memory_allocator                       [system] { header "__memory/allocator.h" }
+module std_private_memory_allocator_arg_t                 [system] { header "__memory/allocator_arg_t.h" }
+module std_private_memory_allocator_destructor            [system] { header "__memory/allocator_destructor.h" }
+module std_private_memory_allocator_traits                [system] { header "__memory/allocator_traits.h" }
+module std_private_memory_assume_aligned                  [system] { header "__memory/assume_aligned.h" }
+module std_private_memory_auto_ptr                        [system] { header "__memory/auto_ptr.h" }
+module std_private_memory_builtin_new_allocator           [system] {
+  header "__memory/builtin_new_allocator.h"
   export *
 }
-module std_math_h [system] {
-  header "math.h"
+module std_private_memory_compressed_pair                 [system] { header "__memory/compressed_pair.h" }
+module std_private_memory_concepts                        [system] {
+  header "__memory/concepts.h"
+  export std_private_type_traits_remove_reference
+}
+module std_private_memory_construct_at                    [system] { header "__memory/construct_at.h" }
+module std_private_memory_destruct_n                      [system] { header "__memory/destruct_n.h" }
+module std_private_memory_fwd                             [system] { header "__fwd/memory.h" }
+module std_private_memory_inout_ptr                       [system] { header "__memory/inout_ptr.h" }
+module std_private_memory_noexcept_move_assign_container  [system] { header "__memory/noexcept_move_assign_container.h" }
+module std_private_memory_out_ptr                         [system] { header "__memory/out_ptr.h" }
+module std_private_memory_pointer_traits                  [system] { header "__memory/pointer_traits.h" }
+module std_private_memory_ranges_construct_at             [system] { header "__memory/ranges_construct_at.h" }
+module std_private_memory_ranges_uninitialized_algorithms [system] {
+  header "__memory/ranges_uninitialized_algorithms.h"
+  export std_private_algorithm_in_out_result
+}
+module std_private_memory_raw_storage_iterator            [system] { header "__memory/raw_storage_iterator.h" }
+module std_private_memory_shared_ptr                      [system] {
+  header "__memory/shared_ptr.h"
+  export std_private_memory_uninitialized_algorithms
+}
+module std_private_memory_swap_allocator                  [system] { header "__memory/swap_allocator.h" }
+module std_private_memory_temp_value                      [system] { header "__memory/temp_value.h" }
+module std_private_memory_temporary_buffer                [system] {
+  header "__memory/temporary_buffer.h"
+  export std_private_utility_pair
+}
+module std_private_memory_uninitialized_algorithms        [system] {
+  header "__memory/uninitialized_algorithms.h"
+  export std_private_algorithm_copy
+}
+module std_private_memory_unique_ptr                      [system] {
+  header "__memory/unique_ptr.h"
+  export std_private_type_traits_add_lvalue_reference
+  export std_private_type_traits_is_pointer
+  export std_private_type_traits_type_identity
+}
+module std_private_memory_unique_temporary_buffer         [system] {
+  header "__memory/unique_temporary_buffer.h"
+  export std_private_memory_unique_ptr
+  export std_private_type_traits_is_constant_evaluated
+}
+module std_private_memory_uses_allocator                  [system] { header "__memory/uses_allocator.h" }
+module std_private_memory_uses_allocator_construction     [system] { header "__memory/uses_allocator_construction.h" }
+module std_private_memory_voidify                         [system] { header "__memory/voidify.h" }
+
+module std_private_memory_resource_memory_resource              [system] { header "__memory_resource/memory_resource.h" }
+module std_private_memory_resource_memory_resource_fwd          [system] { header "__fwd/memory_resource.h" }
+module std_private_memory_resource_monotonic_buffer_resource    [system] { header "__memory_resource/monotonic_buffer_resource.h" }
+module std_private_memory_resource_polymorphic_allocator        [system] { header "__memory_resource/polymorphic_allocator.h" }
+module std_private_memory_resource_pool_options                 [system] { header "__memory_resource/pool_options.h" }
+module std_private_memory_resource_synchronized_pool_resource   [system] {
+  header "__memory_resource/synchronized_pool_resource.h"
   export *
 }
-module std_stdatomic_h [system] {
-  header "stdatomic.h"
+module std_private_memory_resource_unsynchronized_pool_resource [system] { header "__memory_resource/unsynchronized_pool_resource.h" }
+
+module std_private_mutex_lock_guard  [system] { header "__mutex/lock_guard.h" }
+module std_private_mutex_mutex       [system] { header "__mutex/mutex.h" }
+module std_private_mutex_once_flag  [system]  { header "__mutex/once_flag.h" }
+module std_private_mutex_tag_types   [system] { header "__mutex/tag_types.h" }
+module std_private_mutex_unique_lock [system] { header "__mutex/unique_lock.h" }
+
+module std_private_numeric_accumulate               [system] { header "__numeric/accumulate.h" }
+module std_private_numeric_adjacent_difference      [system] { header "__numeric/adjacent_difference.h" }
+module std_private_numeric_exclusive_scan           [system] { header "__numeric/exclusive_scan.h" }
+module std_private_numeric_gcd_lcm                  [system] { header "__numeric/gcd_lcm.h" }
+module std_private_numeric_inclusive_scan           [system] { header "__numeric/inclusive_scan.h" }
+module std_private_numeric_inner_product            [system] { header "__numeric/inner_product.h" }
+module std_private_numeric_iota                     [system] { header "__numeric/iota.h" }
+module std_private_numeric_midpoint                 [system] { header "__numeric/midpoint.h" }
+module std_private_numeric_partial_sum              [system] { header "__numeric/partial_sum.h" }
+module std_private_numeric_pstl                     [system] {
+  header "__numeric/pstl.h"
   export *
 }
-module std_stdbool_h [system] {
-  // <stdbool.h>'s __bool_true_false_are_defined macro requires textual inclusion.
-  textual header "stdbool.h"
+module std_private_numeric_reduce                   [system] { header "__numeric/reduce.h" }
+module std_private_numeric_saturation_arithmetic    [system] { header "__numeric/saturation_arithmetic.h" }
+module std_private_numeric_transform_exclusive_scan [system] { header "__numeric/transform_exclusive_scan.h" }
+module std_private_numeric_transform_inclusive_scan [system] { header "__numeric/transform_inclusive_scan.h" }
+module std_private_numeric_transform_reduce         [system] { header "__numeric/transform_reduce.h" }
+
+module std_private_pstl [system] {
+  header "__pstl/backend.h"
+  header "__pstl/backend_fwd.h"
+  header "__pstl/backends/default.h"
+  header "__pstl/backends/libdispatch.h"
+  header "__pstl/backends/serial.h"
+  header "__pstl/backends/std_thread.h"
+  header "__pstl/cpu_algos/any_of.h"
+  header "__pstl/cpu_algos/cpu_traits.h"
+  header "__pstl/cpu_algos/fill.h"
+  header "__pstl/cpu_algos/find_if.h"
+  header "__pstl/cpu_algos/for_each.h"
+  header "__pstl/cpu_algos/merge.h"
+  header "__pstl/cpu_algos/stable_sort.h"
+  header "__pstl/cpu_algos/transform.h"
+  header "__pstl/cpu_algos/transform_reduce.h"
+  header "__pstl/dispatch.h"
+  header "__pstl/handle_exception.h"
 }
-module std_stddef_h [system] {
-  // <stddef.h>'s __need_* macros require textual inclusion.
-  textual header "stddef.h"
+
+module std_private_queue_fwd [system] { header "__fwd/queue.h" }
+
+module std_private_ostream_basic_ostream [system] {
+  header "__ostream/basic_ostream.h"
+  export std_streambuf
 }
-module std_stdint_h [system] {
-  header "stdint.h"
+module std_private_ostream_print         [system] {
+  header "__ostream/print.h"
+  export std_print
+}
+
+module std_private_random_bernoulli_distribution          [system] { header "__random/bernoulli_distribution.h" }
+module std_private_random_binomial_distribution           [system] { header "__random/binomial_distribution.h" }
+module std_private_random_cauchy_distribution             [system] { header "__random/cauchy_distribution.h" }
+module std_private_random_chi_squared_distribution        [system] { header "__random/chi_squared_distribution.h" }
+module std_private_random_clamp_to_integral               [system] { header "__random/clamp_to_integral.h" }
+module std_private_random_default_random_engine           [system] { header "__random/default_random_engine.h" }
+module std_private_random_discard_block_engine            [system] { header "__random/discard_block_engine.h" }
+module std_private_random_discrete_distribution           [system] {
+  header "__random/discrete_distribution.h"
   export *
 }
-module std_stdio_h [system] {
-  // <stdio.h>'s __need_* macros require textual inclusion.
-  textual header "stdio.h"
+module std_private_random_exponential_distribution        [system] { header "__random/exponential_distribution.h" }
+module std_private_random_extreme_value_distribution      [system] { header "__random/extreme_value_distribution.h" }
+module std_private_random_fisher_f_distribution           [system] { header "__random/fisher_f_distribution.h" }
+module std_private_random_gamma_distribution              [system] { header "__random/gamma_distribution.h" }
+module std_private_random_generate_canonical              [system] { header "__random/generate_canonical.h" }
+module std_private_random_geometric_distribution          [system] { header "__random/geometric_distribution.h" }
+module std_private_random_independent_bits_engine         [system] { header "__random/independent_bits_engine.h" }
+module std_private_random_is_seed_sequence                [system] { header "__random/is_seed_sequence.h" }
+module std_private_random_is_valid                        [system] { header "__random/is_valid.h" }
+module std_private_random_knuth_b                         [system] { header "__random/knuth_b.h" }
+module std_private_random_linear_congruential_engine      [system] { header "__random/linear_congruential_engine.h" }
+module std_private_random_log2                            [system] { header "__random/log2.h" }
+module std_private_random_lognormal_distribution          [system] { header "__random/lognormal_distribution.h" }
+module std_private_random_mersenne_twister_engine         [system] { header "__random/mersenne_twister_engine.h" }
+module std_private_random_negative_binomial_distribution  [system] { header "__random/negative_binomial_distribution.h" }
+module std_private_random_normal_distribution             [system] { header "__random/normal_distribution.h" }
+module std_private_random_piecewise_constant_distribution [system] {
+  header "__random/piecewise_constant_distribution.h"
+  export *
 }
-module std_stdlib_h [system] {
-  // <stdlib.h>'s __need_* macros require textual inclusion.
-  textual header "stdlib.h"
+module std_private_random_piecewise_linear_distribution   [system] {
+  header "__random/piecewise_linear_distribution.h"
+  export *
 }
-module std_string_h [system] {
-  header "string.h"
+module std_private_random_poisson_distribution            [system] { header "__random/poisson_distribution.h" }
+module std_private_random_random_device                   [system] {
+  header "__random/random_device.h"
   export *
 }
-module std_tgmath_h [system] {
-  header "tgmath.h"
+module std_private_random_ranlux                          [system] { header "__random/ranlux.h" }
+module std_private_random_seed_seq                        [system] {
+  header "__random/seed_seq.h"
   export *
 }
-module std_uchar_h [system] {
-  header "uchar.h"
+module std_private_random_shuffle_order_engine            [system] { header "__random/shuffle_order_engine.h" }
+module std_private_random_student_t_distribution          [system] { header "__random/student_t_distribution.h" }
+module std_private_random_subtract_with_carry_engine      [system] { header "__random/subtract_with_carry_engine.h" }
+module std_private_random_uniform_int_distribution        [system] { header "__random/uniform_int_distribution.h" }
+module std_private_random_uniform_random_bit_generator    [system] { header "__random/uniform_random_bit_generator.h" }
+module std_private_random_uniform_real_distribution       [system] { header "__random/uniform_real_distribution.h" }
+module std_private_random_weibull_distribution            [system] { header "__random/weibull_distribution.h" }
+
+module std_private_ranges_access                     [system] { header "__ranges/access.h" }
+module std_private_ranges_all                        [system] {
+  header "__ranges/all.h"
+  export std_private_functional_compose
+  export std_private_functional_perfect_forward
+  export std_private_ranges_owning_view
+}
+module std_private_ranges_as_rvalue_view             [system] { header "__ranges/as_rvalue_view.h" }
+module std_private_ranges_chunk_by_view              [system] { header "__ranges/chunk_by_view.h" }
+module std_private_ranges_common_view                [system] { header "__ranges/common_view.h" }
+module std_private_ranges_concepts                   [system] {
+  header "__ranges/concepts.h"
+  export std_private_iterator_concepts
+}
+module std_private_ranges_container_compatible_range [system] { header "__ranges/container_compatible_range.h" }
+module std_private_ranges_counted                    [system] {
+  header "__ranges/counted.h"
+  export std_span
+}
+module std_private_ranges_dangling                   [system] { header "__ranges/dangling.h" }
+module std_private_ranges_data                       [system] { header "__ranges/data.h" }
+module std_private_ranges_drop_view                  [system] { header "__ranges/drop_view.h" }
+module std_private_ranges_drop_while_view            [system] { header "__ranges/drop_while_view.h" }
+module std_private_ranges_elements_view              [system] { header "__ranges/elements_view.h" }
+module std_private_ranges_empty                      [system] { header "__ranges/empty.h" }
+module std_private_ranges_empty_view                 [system] { header "__ranges/empty_view.h" }
+module std_private_ranges_enable_borrowed_range      [system] { header "__ranges/enable_borrowed_range.h" }
+module std_private_ranges_enable_view                [system] { header "__ranges/enable_view.h" }
+module std_private_ranges_filter_view                [system] {
+  header "__ranges/filter_view.h"
+  export std_private_ranges_range_adaptor
+}
+module std_private_ranges_from_range                 [system] { header "__ranges/from_range.h" }
+module std_private_ranges_iota_view                  [system] { header "__ranges/iota_view.h" }
+module std_private_ranges_istream_view               [system] {
+  header "__ranges/istream_view.h"
+}
+module std_private_ranges_join_view                  [system] {
+  header "__ranges/join_view.h"
+  export std_private_iterator_iterator_with_data
+  export std_private_iterator_segmented_iterator
+}
+module std_private_ranges_lazy_split_view            [system] {
+  header "__ranges/lazy_split_view.h"
+  export std_private_ranges_non_propagating_cache
+}
+module std_private_ranges_movable_box                [system] { header "__ranges/movable_box.h" }
+module std_private_ranges_non_propagating_cache      [system] { header "__ranges/non_propagating_cache.h" }
+module std_private_ranges_owning_view                [system] { header "__ranges/owning_view.h" }
+module std_private_ranges_range_adaptor              [system] { header "__ranges/range_adaptor.h" }
+module std_private_ranges_rbegin                     [system] { header "__ranges/rbegin.h" }
+module std_private_ranges_ref_view                   [system] { header "__ranges/ref_view.h" }
+module std_private_ranges_rend                       [system] { header "__ranges/rend.h" }
+module std_private_ranges_repeat_view                [system] { header "__ranges/repeat_view.h" }
+module std_private_ranges_reverse_view               [system] { header "__ranges/reverse_view.h" }
+module std_private_ranges_single_view                [system] { header "__ranges/single_view.h" }
+module std_private_ranges_size                       [system] {
+  header "__ranges/size.h"
+  export std_private_type_traits_make_unsigned
+}
+module std_private_ranges_split_view                 [system] { header "__ranges/split_view.h" }
+module std_private_ranges_subrange                   [system] {
+  header "__ranges/subrange.h"
+  export std_private_ranges_subrange_fwd
+}
+module std_private_ranges_subrange_fwd               [system] {
+  header "__fwd/subrange.h"
+  export std_private_iterator_concepts
+}
+module std_private_ranges_take_view                  [system] { header "__ranges/take_view.h" }
+module std_private_ranges_take_while_view            [system] { header "__ranges/take_while_view.h" }
+module std_private_ranges_to                         [system] { header "__ranges/to.h" }
+module std_private_ranges_transform_view             [system] {
+  header "__ranges/transform_view.h"
+  export std_private_functional_bind_back
+  export std_private_functional_perfect_forward
+  export std_private_ranges_movable_box
+}
+module std_private_ranges_view_interface             [system] { header "__ranges/view_interface.h" }
+module std_private_ranges_views                      [system] { header "__ranges/views.h" }
+module std_private_ranges_zip_view                   [system] {
+  header "__ranges/zip_view.h"
+  export std_private_utility_pair
+}
+
+module std_private_span_span_fwd [system] { header "__fwd/span.h" }
+
+module std_private_stack_fwd [system] { header "__fwd/stack.h" }
+
+module std_private_string_char_traits           [system] {
+  header "__string/char_traits.h"
   export *
 }
-module std_wchar_h [system] {
-  // <wchar.h>'s __need_* macros require textual inclusion.
-  textual header "wchar.h"
+module std_private_string_constexpr_c_functions [system] {
+  header "__string/constexpr_c_functions.h"
+  export std_private_type_traits_is_equality_comparable
 }
-module std_wctype_h [system] {
-  header "wctype.h"
+module std_private_string_extern_template_lists [system] { header "__string/extern_template_lists.h" }
+module std_private_string_string_fwd            [system] { header "__fwd/string.h" }
+
+module std_private_string_view_string_view_fwd [system] { header "__fwd/string_view.h" }
+
+module std_private_system_error_errc            [system] { header "__system_error/errc.h" }
+module std_private_system_error_error_category  [system] { header "__system_error/error_category.h" }
+module std_private_system_error_error_code      [system] {
+  header "__system_error/error_code.h"
+  export std_private_functional_hash
+  export std_private_functional_unary_function
+}
+module std_private_system_error_error_condition [system] {
+  header "__system_error/error_condition.h"
+  export std_private_functional_hash
+  export std_private_functional_unary_function
+}
+module std_private_system_error_system_error    [system] { header "__system_error/system_error.h" }
+
+module std_private_thread_formatter            [system] { header "__thread/formatter.h" }
+module std_private_thread_id                   [system] { header "__thread/id.h" }
+module std_private_thread_jthread              [system] {
+  header "__thread/jthread.h"
+  export *
+}
+module std_private_thread_poll_with_backoff    [system] { header "__thread/poll_with_backoff.h" }
+module std_private_thread_support              [system] {
+  header "__thread/support.h"
   export *
 }
+module std_private_thread_support_c11          [system] { textual header "__thread/support/c11.h" }
+module std_private_thread_support_external     [system] { textual header "__thread/support/external.h" }
+module std_private_thread_support_pthread      [system] { textual header "__thread/support/pthread.h" }
+module std_private_thread_support_windows      [system] { textual header "__thread/support/windows.h" }
+module std_private_thread_this_thread          [system] { header "__thread/this_thread.h" }
+module std_private_thread_thread               [system] {
+  header "__thread/thread.h"
+  export *
+}
+module std_private_thread_timed_backoff_policy [system] { header "__thread/timed_backoff_policy.h" }
 
-// This header is used by other C compatibility headers so it needs to be in its own module.
-module std_private_mbstate_t [system] {
-  header "__mbstate_t.h"
+module std_private_tuple_find_index             [system] { header "__tuple/find_index.h" }
+module std_private_tuple_ignore                 [system] { header "__tuple/ignore.h" }
+module std_private_tuple_make_tuple_types       [system] { header "__tuple/make_tuple_types.h" }
+module std_private_tuple_tuple_like_no_subrange [system] {
+  header "__tuple/tuple_like_no_subrange.h"
+}
+module std_private_tuple_sfinae_helpers         [system] { header "__tuple/sfinae_helpers.h" }
+module std_private_tuple_tuple_element          [system] { header "__tuple/tuple_element.h" }
+module std_private_tuple_tuple_fwd              [system] { header "__fwd/tuple.h" }
+module std_private_get_fwd                      [system] {
+  header "__fwd/get.h"
+  export std_private_array_array_fwd
+  export std_private_complex_complex_fwd
+  export std_private_ranges_subrange_fwd
+  export std_private_tuple_tuple_fwd
+  export std_private_utility_pair_fwd
+  export std_private_variant_fwd
+}
+module std_private_tuple_tuple_indices          [system] { header "__tuple/tuple_indices.h" }
+module std_private_tuple_tuple_like             [system] {
+  header "__tuple/tuple_like.h"
   export *
 }
+module std_private_tuple_tuple_like_ext         [system] { header "__tuple/tuple_like_ext.h" }
+module std_private_tuple_tuple_size             [system] {
+  header "__tuple/tuple_size.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_tuple_tuple_types            [system] { header "__tuple/tuple_types.h" }
+
+module std_private_type_traits_add_const                                 [system] { header "__type_traits/add_const.h" }
+module std_private_type_traits_add_cv                                    [system] { header "__type_traits/add_cv.h" }
+module std_private_type_traits_add_lvalue_reference                      [system] {
+  header "__type_traits/add_lvalue_reference.h"
+  export std_private_type_traits_is_referenceable
+}
+module std_private_type_traits_add_pointer                               [system] { header "__type_traits/add_pointer.h" }
+module std_private_type_traits_add_rvalue_reference                      [system] { header "__type_traits/add_rvalue_reference.h" }
+module std_private_type_traits_add_volatile                              [system] { header "__type_traits/add_volatile.h" }
+module std_private_type_traits_aligned_storage                           [system] { header "__type_traits/aligned_storage.h" }
+module std_private_type_traits_aligned_union                             [system] { header "__type_traits/aligned_union.h" }
+module std_private_type_traits_alignment_of                              [system] { header "__type_traits/alignment_of.h" }
+module std_private_type_traits_can_extract_key                           [system] { header "__type_traits/can_extract_key.h" }
+module std_private_type_traits_common_reference                          [system] {
+  header "__type_traits/common_reference.h"
+  export std_private_type_traits_remove_cvref
+}
+module std_private_type_traits_common_type                               [system] {
+  header "__type_traits/common_type.h"
+  export std_private_type_traits_type_identity
+  export std_private_utility_declval
+  export std_private_utility_empty
+}
+module std_private_type_traits_conditional                               [system] { header "__type_traits/conditional.h" }
+module std_private_type_traits_conjunction                               [system] { header "__type_traits/conjunction.h" }
+module std_private_type_traits_copy_cv                                   [system] { header "__type_traits/copy_cv.h" }
+module std_private_type_traits_copy_cvref                                [system] { header "__type_traits/copy_cvref.h" }
+module std_private_type_traits_datasizeof                                [system] { header "__type_traits/datasizeof.h" }
+module std_private_type_traits_decay                                     [system] {
+  header "__type_traits/decay.h"
+  export std_private_type_traits_add_pointer
+}
+module std_private_type_traits_dependent_type                            [system] { header "__type_traits/dependent_type.h" }
+module std_private_type_traits_desugars_to                               [system] { header "__type_traits/desugars_to.h" }
+module std_private_type_traits_disjunction                               [system] { header "__type_traits/disjunction.h" }
+module std_private_type_traits_enable_if                                 [system] { header "__type_traits/enable_if.h" }
+module std_private_type_traits_extent                                    [system] { header "__type_traits/extent.h" }
+module std_private_type_traits_has_unique_object_representation          [system] { header "__type_traits/has_unique_object_representation.h" }
+module std_private_type_traits_has_virtual_destructor                    [system] { header "__type_traits/has_virtual_destructor.h" }
+module std_private_type_traits_integral_constant                         [system] { header "__type_traits/integral_constant.h" }
+module std_private_type_traits_invoke                                    [system] {
+  header "__type_traits/invoke.h"
+  export std_private_type_traits_conditional
+  export std_private_type_traits_decay
+  export std_private_type_traits_decay
+  export std_private_type_traits_enable_if
+  export std_private_type_traits_is_base_of
+  export std_private_type_traits_is_core_convertible
+  export std_private_type_traits_is_reference_wrapper
+  export std_private_type_traits_is_same
+  export std_private_type_traits_is_void
+  export std_private_type_traits_nat
+  export std_private_type_traits_remove_cv
+}
+module std_private_type_traits_is_abstract                               [system] { header "__type_traits/is_abstract.h" }
+module std_private_type_traits_is_aggregate                              [system] { header "__type_traits/is_aggregate.h" }
+module std_private_type_traits_is_allocator                              [system] { header "__type_traits/is_allocator.h" }
+module std_private_type_traits_is_always_bitcastable                     [system] { header "__type_traits/is_always_bitcastable.h" }
+module std_private_type_traits_is_arithmetic                             [system] {
+  header "__type_traits/is_arithmetic.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_array                                  [system] {
+  header "__type_traits/is_array.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_assignable                             [system] { header "__type_traits/is_assignable.h" }
+module std_private_type_traits_is_base_of                                [system] { header "__type_traits/is_base_of.h" }
+module std_private_type_traits_is_bounded_array                          [system] { header "__type_traits/is_bounded_array.h" }
+module std_private_type_traits_is_callable                               [system] {
+  header "__type_traits/is_callable.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_char_like_type                         [system] { header "__type_traits/is_char_like_type.h" }
+module std_private_type_traits_is_class                                  [system] { header "__type_traits/is_class.h" }
+module std_private_type_traits_is_compound                               [system] { header "__type_traits/is_compound.h" }
+module std_private_type_traits_is_const                                  [system] { header "__type_traits/is_const.h" }
+module std_private_type_traits_is_constant_evaluated                     [system] { header "__type_traits/is_constant_evaluated.h" }
+module std_private_type_traits_is_constructible                          [system] { header "__type_traits/is_constructible.h" }
+module std_private_type_traits_is_convertible                            [system] {
+  header "__type_traits/is_convertible.h"
+  export std_private_type_traits_is_array
+}
+module std_private_type_traits_is_copy_assignable                        [system] { header "__type_traits/is_copy_assignable.h" }
+module std_private_type_traits_is_copy_constructible                     [system] { header "__type_traits/is_copy_constructible.h" }
+module std_private_type_traits_is_core_convertible                       [system] {
+  header "__type_traits/is_core_convertible.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_destructible                           [system] { header "__type_traits/is_destructible.h" }
+module std_private_type_traits_is_empty                                  [system] { header "__type_traits/is_empty.h" }
+module std_private_type_traits_is_enum                                   [system] {
+  header "__type_traits/is_enum.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_equality_comparable                    [system] {
+  header "__type_traits/is_equality_comparable.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_execution_policy                       [system] {
+  header "__type_traits/is_execution_policy.h"
+  export std_private_type_traits_remove_cvref
+}
+module std_private_type_traits_is_final                                  [system] { header "__type_traits/is_final.h" }
+module std_private_type_traits_is_floating_point                         [system] { header "__type_traits/is_floating_point.h" }
+module std_private_type_traits_is_function                               [system] { header "__type_traits/is_function.h" }
+module std_private_type_traits_is_fundamental                            [system] { header "__type_traits/is_fundamental.h" }
+module std_private_type_traits_is_implicitly_default_constructible       [system] {
+  header "__type_traits/is_implicitly_default_constructible.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_integral                               [system] {
+  header "__type_traits/is_integral.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_literal_type                           [system] { header "__type_traits/is_literal_type.h" }
+module std_private_type_traits_is_member_pointer                         [system] { header "__type_traits/is_member_pointer.h" }
+module std_private_type_traits_is_nothrow_assignable                     [system] { header "__type_traits/is_nothrow_assignable.h" }
+module std_private_type_traits_is_nothrow_constructible                  [system] {
+  header "__type_traits/is_nothrow_constructible.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_nothrow_convertible                    [system] { header "__type_traits/is_nothrow_convertible.h" }
+module std_private_type_traits_is_nothrow_destructible                   [system] {
+  header "__type_traits/is_nothrow_destructible.h"
+  export std_private_type_traits_is_destructible
+}
+module std_private_type_traits_is_null_pointer                           [system] {
+  header "__type_traits/is_null_pointer.h"
+  export std_cstddef
+}
+module std_private_type_traits_is_object                                 [system] {
+  header "__type_traits/is_object.h"
+  export std_private_type_traits_is_scalar
+}
+module std_private_type_traits_is_pod                                    [system] { header "__type_traits/is_pod.h" }
+module std_private_type_traits_is_pointer                                [system] { header "__type_traits/is_pointer.h" }
+module std_private_type_traits_is_polymorphic                            [system] { header "__type_traits/is_polymorphic.h" }
+module std_private_type_traits_is_primary_template                       [system] {
+  header "__type_traits/is_primary_template.h"
+  export std_private_type_traits_enable_if
+}
+module std_private_type_traits_is_reference                              [system] {
+  header "__type_traits/is_reference.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_reference_wrapper                      [system] { header "__type_traits/is_reference_wrapper.h" }
+module std_private_type_traits_is_referenceable                          [system] { header "__type_traits/is_referenceable.h" }
+module std_private_type_traits_is_same                                   [system] {
+  header "__type_traits/is_same.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_scalar                                 [system] {
+  header "__type_traits/is_scalar.h"
+  export std_private_type_traits_is_null_pointer
+}
+module std_private_type_traits_is_signed                                 [system] { header "__type_traits/is_signed.h" }
+module std_private_type_traits_is_signed_integer                         [system] { header "__type_traits/is_signed_integer.h" }
+module std_private_type_traits_is_specialization                         [system] { header "__type_traits/is_specialization.h" }
+module std_private_type_traits_is_standard_layout                        [system] { header "__type_traits/is_standard_layout.h" }
+module std_private_type_traits_is_swappable                              [system] {
+  header "__type_traits/is_swappable.h"
+  export std_private_type_traits_is_move_constructible
+}
+module std_private_type_traits_is_trivial                                [system] { header "__type_traits/is_trivial.h" }
+module std_private_type_traits_is_trivially_assignable                   [system] { header "__type_traits/is_trivially_assignable.h" }
+module std_private_type_traits_is_trivially_constructible                [system] { header "__type_traits/is_trivially_constructible.h" }
+module std_private_type_traits_is_trivially_copyable                     [system] {
+  header "__type_traits/is_trivially_copyable.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_trivially_destructible                 [system] { header "__type_traits/is_trivially_destructible.h" }
+module std_private_type_traits_is_trivially_lexicographically_comparable [system] { header "__type_traits/is_trivially_lexicographically_comparable.h" }
+module std_private_type_traits_is_trivially_relocatable                  [system] { header "__type_traits/is_trivially_relocatable.h" }
+module std_private_type_traits_is_unbounded_array                        [system] { header "__type_traits/is_unbounded_array.h" }
+module std_private_type_traits_is_union                                  [system] { header "__type_traits/is_union.h" }
+module std_private_type_traits_is_unsigned                               [system] { header "__type_traits/is_unsigned.h" }
+module std_private_type_traits_is_unsigned_integer                       [system] { header "__type_traits/is_unsigned_integer.h" }
+module std_private_type_traits_is_valid_expansion                        [system] { header "__type_traits/is_valid_expansion.h" }
+module std_private_type_traits_is_void                                   [system] {
+  header "__type_traits/is_void.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_type_traits_is_volatile                               [system] { header "__type_traits/is_volatile.h" }
+module std_private_type_traits_lazy                                      [system] { header "__type_traits/lazy.h" }
+module std_private_type_traits_make_32_64_or_128_bit                     [system] { header "__type_traits/make_32_64_or_128_bit.h" }
+module std_private_type_traits_make_const_lvalue_ref                     [system] { header "__type_traits/make_const_lvalue_ref.h" }
+module std_private_type_traits_make_signed                               [system] { header "__type_traits/make_signed.h" }
+module std_private_type_traits_make_unsigned                             [system] {
+  header "__type_traits/make_unsigned.h"
+  export std_private_type_traits_is_unsigned
+}
+module std_private_type_traits_maybe_const                               [system] { header "__type_traits/maybe_const.h" }
+module std_private_type_traits_nat                                       [system] { header "__type_traits/nat.h" }
+module std_private_type_traits_negation                                  [system] { header "__type_traits/negation.h" }
+module std_private_type_traits_promote                                   [system] { header "__type_traits/promote.h" }
+module std_private_type_traits_rank                                      [system] { header "__type_traits/rank.h" }
+module std_private_type_traits_remove_all_extents                        [system] { header "__type_traits/remove_all_extents.h" }
+module std_private_type_traits_remove_const                              [system] { header "__type_traits/remove_const.h" }
+module std_private_type_traits_remove_const_ref                          [system] { header "__type_traits/remove_const_ref.h" }
+module std_private_type_traits_remove_cv                                 [system] {
+  header "__type_traits/remove_cv.h"
+  export std_private_type_traits_remove_const
+  export std_private_type_traits_remove_volatile
+}
+module std_private_type_traits_remove_cvref                              [system] { header "__type_traits/remove_cvref.h" }
+module std_private_type_traits_remove_extent                             [system] { header "__type_traits/remove_extent.h" }
+module std_private_type_traits_remove_pointer                            [system] { header "__type_traits/remove_pointer.h" }
+module std_private_type_traits_remove_reference                          [system] { header "__type_traits/remove_reference.h" }
+module std_private_type_traits_remove_volatile                           [system] { header "__type_traits/remove_volatile.h" }
+module std_private_type_traits_result_of                                 [system] { header "__type_traits/result_of.h" }
+module std_private_type_traits_strip_signature                           [system] { header "__type_traits/strip_signature.h" }
+module std_private_type_traits_type_identity                             [system] { header "__type_traits/type_identity.h" }
+module std_private_type_traits_type_list                                 [system] { header "__type_traits/type_list.h" }
+module std_private_type_traits_underlying_type                           [system] {
+  header "__type_traits/underlying_type.h"
+  export std_private_type_traits_is_enum
+}
+module std_private_type_traits_unwrap_ref                                [system] { header "__type_traits/unwrap_ref.h" }
+module std_private_type_traits_void_t                                    [system] { header "__type_traits/void_t.h" }
+
+module std_private_utility_as_const               [system] { header "__utility/as_const.h" }
+module std_private_utility_as_lvalue              [system] { header "__utility/as_lvalue.h" }
+module std_private_utility_auto_cast              [system] {
+  header "__utility/auto_cast.h"
+  export std_private_type_traits_decay
+}
+module std_private_utility_cmp                    [system] {
+  header "__utility/cmp.h"
+  export std_private_type_traits_make_unsigned
+}
+module std_private_utility_convert_to_integral    [system] { header "__utility/convert_to_integral.h" }
+module std_private_utility_declval                [system] { header "__utility/declval.h" }
+module std_private_utility_empty                  [system] { header "__utility/empty.h" }
+module std_private_utility_exception_guard        [system] { header "__utility/exception_guard.h" }
+module std_private_utility_exchange               [system] { header "__utility/exchange.h" }
+module std_private_utility_forward                [system] { header "__utility/forward.h" }
+module std_private_utility_forward_like           [system] { header "__utility/forward_like.h" }
+module std_private_utility_in_place               [system] {
+  header "__utility/in_place.h"
+  export std_private_type_traits_integral_constant
+}
+module std_private_utility_integer_sequence       [system] { header "__utility/integer_sequence.h" }
+module std_private_utility_is_pointer_in_range    [system] { header "__utility/is_pointer_in_range.h" }
+module std_private_utility_is_valid_range         [system] { header "__utility/is_valid_range.h" }
+module std_private_utility_move                   [system] {
+  header "__utility/move.h"
+  export std_private_type_traits_is_copy_constructible
+  export std_private_type_traits_is_nothrow_move_constructible
+  export std_private_type_traits_remove_reference
+}
+module std_private_utility_no_destroy             [system] { header "__utility/no_destroy.h" }
+module std_private_utility_pair                   [system] {
+  header "__utility/pair.h"
+  export std_private_ranges_subrange_fwd
+  export std_private_tuple_pair_like
+  export std_private_type_traits_is_assignable
+  export std_private_type_traits_is_constructible
+  export std_private_type_traits_is_convertible
+  export std_private_type_traits_is_copy_assignable
+  export std_private_type_traits_is_move_assignable
+  export std_private_type_traits_is_nothrow_copy_constructible
+  export std_private_type_traits_is_nothrow_default_constructible
+  export std_private_type_traits_is_nothrow_move_assignable
+  export std_private_utility_pair_fwd
+}
+module std_private_utility_pair_fwd                [system] { header "__fwd/pair.h" }
+module std_private_utility_piecewise_construct     [system] { header "__utility/piecewise_construct.h" }
+module std_private_utility_priority_tag            [system] { header "__utility/priority_tag.h" }
+module std_private_utility_private_constructor_tag [system] { header "__utility/private_constructor_tag.h" }
+module std_private_utility_rel_ops                 [system] { header "__utility/rel_ops.h" }
+module std_private_utility_small_buffer            [system] { header "__utility/small_buffer.h" }
+module std_private_utility_swap                    [system] {
+  header "__utility/swap.h"
+  export std_private_type_traits_is_swappable
+}
+module std_private_utility_to_underlying           [system] { header "__utility/to_underlying.h" }
+module std_private_utility_unreachable             [system] { header "__utility/unreachable.h" }
+
+module std_private_variant_monostate               [system] { header "__variant/monostate.h" }
+module std_private_variant_fwd                     [system] { header "__fwd/variant.h" }
+
+module std_private_vector_fwd                      [system] { header "__fwd/vector.h" }
diff --git a/libcxx/test/libcxx/clang_modules_include.gen.py b/libcxx/test/libcxx/clang_modules_include.gen.py
index bc028f2a0809aa..f0421b2e738133 100644
--- a/libcxx/test/libcxx/clang_modules_include.gen.py
+++ b/libcxx/test/libcxx/clang_modules_include.gen.py
@@ -37,17 +37,13 @@
 // TODO: Investigate this failure
 // UNSUPPORTED: LIBCXX-FREEBSD-FIXME
 
-// TODO: Investigate why this doesn't work on Picolibc once the locale base API is refactored
-// UNSUPPORTED: LIBCXX-PICOLIBC-FIXME
-
 {lit_header_restrictions.get(header, '')}
 
 #include <{header}>
 """)
 
-print(
-    f"""\
-//--- import_std.compile.pass.mm
+print(f"""\
+//--- __std_clang_module.compile.pass.mm
 // RUN: %{{cxx}} %s %{{flags}} %{{compile_flags}} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only
 
 // REQUIRES: clang-modules-build
@@ -65,10 +61,6 @@
 // TODO: Investigate this failure
 // UNSUPPORTED: LIBCXX-FREEBSD-FIXME
 
-// TODO: Investigate why this doesn't work on Picolibc once the locale base API is refactored
-// UNSUPPORTED: LIBCXX-PICOLIBC-FIXME
-
 @import std;
 
-"""
-)
+""")
diff --git a/libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp b/libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
new file mode 100644
index 00000000000000..7e27adfab1971e
--- /dev/null
+++ b/libcxx/test/std/experimental/utilities/utility/utility.synop/includes.pass.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/utility>
+
+#include <experimental/utility>
+
+#include "test_macros.h"
+
+#ifndef _LIBCPP_UTILITY
+#   error "<experimental/utility> must include <utility>"
+#endif
+
+int main(int, char**)
+{
+
+  return 0;
+}
diff --git a/libcxx/utils/CMakeLists.txt b/libcxx/utils/CMakeLists.txt
index 027e485fc15ef1..1116531fa06539 100644
--- a/libcxx/utils/CMakeLists.txt
+++ b/libcxx/utils/CMakeLists.txt
@@ -2,6 +2,10 @@ add_custom_target(libcxx-generate-feature-test-macros
     COMMAND "${Python3_EXECUTABLE}" "${LIBCXX_SOURCE_DIR}/utils/generate_feature_test_macro_components.py"
     COMMENT "Generate the <version> header and tests for feature test macros.")
 
+add_custom_target(libcxx-generate-std-clang-module-header
+  COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/generate_std_clang_module_header.py"
+  COMMENT "Generate the <__std_clang_module> header")
+
 add_custom_target(libcxx-generate-std-cppm-in-file
   COMMAND
         "${Python3_EXECUTABLE}"
@@ -53,6 +57,7 @@ add_custom_target(libcxx-indic-conjunct-break-table
 
 add_custom_target(libcxx-generate-files
     DEPENDS libcxx-generate-feature-test-macros
+            libcxx-generate-std-clang-module-header
             libcxx-generate-std-cppm-in-file
             libcxx-generate-std-compat-cppm-in-file
             libcxx-generate-extended-grapheme-cluster-tables
diff --git a/libcxx/utils/generate_std_clang_module_header.py b/libcxx/utils/generate_std_clang_module_header.py
new file mode 100644
index 00000000000000..33c9acf3953796
--- /dev/null
+++ b/libcxx/utils/generate_std_clang_module_header.py
@@ -0,0 +1,63 @@
+# ===----------------------------------------------------------------------===##
+#
+# 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 os.path
+
+import libcxx.header_information
+
+header_restrictions = libcxx.header_information.header_restrictions
+
+libcxx_include_directory = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "include"
+)
+with open(
+    os.path.join(libcxx_include_directory, "__std_clang_module"), "w"
+) as std_clang_module_header:
+    std_clang_module_header.write(
+        """\
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// WARNING, this entire header is generated by
+// utils/generate_std_clang_module_header.py
+// DO NOT MODIFY!
+
+// This header should not be directly included, it's exclusively to import all
+// of the libc++ public clang modules for the `std` clang module to export. In
+// other words, it's to facilitate `@import std;` in Objective-C++ and `import std`
+// in Swift to expose all of the libc++ interfaces. This is generally not
+// recommended, however there are some clients that need to import all of libc++
+// without knowing what "all" is.
+#if !__building_module(std)
+#  error "Do not include this header directly, include individual headers instead"
+#endif
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+"""
+    )
+    # Include the angle brackets in sorting so that <a.h> sorts before <a>
+    # like check-format wants.
+    for include, header in sorted([(f"<{header}>", header) for header in libcxx.header_information.public_headers]):
+        header_restriction = header_restrictions.get(header)
+        if header_restriction:
+            std_clang_module_header.write(f"#if {header_restriction}\n")
+            std_clang_module_header.write(f"#  include {include}\n")
+            std_clang_module_header.write(f"#endif\n")
+        else:
+            std_clang_module_header.write(f"#include {include}\n")



More information about the libcxx-commits mailing list