[libc++] Reduces the number of transitive includes.

[Mordante]

Summary

This defines a new policy for removal of transitive includes.
The goal of the policy it to make it relatively easy to remove
headers when needed, but avoid breaking developers using and
vendors shipping libc++.

The method used is to guard transitive includes based on the
C++ language version. For the upcoming C++23 we can remove
headers when we want, but for other language versions we try
to keep it to a minimum.

In this code the transitive include of <chrono> is removed
since D128577 introduces a header cycle between <format>
and <chrono>. This cycle is indirectly required by the
Standard. Our cycle dependency tool basically is a grep based
tool, so it needs some hints to ignore cycles. With the input
of our transitive include tests we can create a better tool.
However that's out of the scope of this patch.

Note the flag _LIBCPP_REMOVE_TRANSITIVE_INCLUDES remains
unchanged. So users can still opt-out of transitives includes
entirely.

[Mordante]

Test.

[Mordante]

Change the includes.

[Mordante]

Test

[Mordante]

Polishing, adding documentation, fixing some CI issues.

[Mordante]

Fix CI.

[Mordante]

Attempt to fix Windows.

[Mordante]

libcxx/include/chrono

692 ↗

(On Diff #454298)

Note this doesn't belong in this patch. It's a test to see whether we can fix the build issues in D128577.

[ldionne]

I think this is a great step forward, but it does raise some interesting/annoying questions. I think we can solve all of them, though.

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

19–21

23–26

28–32

34

45–48

50

Instead of this, I would suggest:

1. Adding a new libcxx-generate-public-header-graph job that produces all the expected.FOO headers using clang --trace-includes
2. This should allow getting rid of regenerate_expected_results = False/True in libcxx/test/libcxx/transitive_includes.sh.cpp.
3. Rewrite graph_header_deps.py to use that data instead of the naive grep-based parsing it has right now.

This is fine to do as a follow-up.

libcxx/docs/ReleaseNotes.rst

48–62

libcxx/include/chrono

686 ↗

(On Diff #454298)

I would like to investigate this instead:

#if _BUILDING_ON_WINDOWS_DLL // don't require usage of libexperimental cause it doesn't work yet
  virtual ~format_error() noexcept { }
#endif

I'm not sure it will be better, but we should try it out. It seems more localized to me.

libcxx/test/libcxx/transitive_includes/expected.algorithm

1 ↗

(On Diff #454298)

This is extremely unfortunate, but I think that we *have* to generate these headers for each language version if we move forward with this patch. Otherwise, we defeat the whole purpose of having this framework in place to prevent transitive include removal regressions.

17 ↗

(On Diff #454298)

We should keep the C++20 removals as minimal as possible. You should keep including <iterator>, <utility> and <variant> explicitly from <algorithm> in <= C++20, but drop them in C++23.

[Mordante]

Test Windows build based on ldionne's suggestion.

[Mordante]

Try to fix the build.

[Mordante]

Fix CI.

[Mordante]

Fix other Windows build.

[ldionne]

libcxx/utils/ci/run-buildbot

570 ↗

(On Diff #455144)

I think we should define _LIBCPP_INLINE_FORMAT_ERROR_DTOR inside __config instead. This is a general property of clang-cl / DLL builds, not only our CI build. IOW, we should enable the inline dtor if someone builds DLLs using clang-cl at their desk, which wouldn't be the case right now.

[Mordante]

Test another way to fix the Windows build.

[Mordante]

Addresses review comments.
Removes unrelated changes, these have been moved to other patches.
Rebased on top of D132584, to include the new transitve include test framework.

[Mordante]

libcxx/include/algorithm

1902–1906

During the live code review we discussed to move these transitive includes to the end of the file. That will be done in a followup patch.

libcxx/include/chrono

686 ↗

(On Diff #454298)

Fixed in D132667 in the suggested way. The changes are removed here.

libcxx/test/libcxx/transitive_includes/expected.algorithm

1 ↗

(On Diff #454298)

Solved in D132534 and D132584.

[mumbleskates]

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

35

Sentence fragment terminates here

libcxx/docs/ReleaseNotes.rst

62–64

Is "the future" here major releases? years? If this deeply affected me I would want to know a lot more about what kind of timeline I was guaranteed, given "regardless of the language version in use".

[philnik]

Assuming we still plan to remove transitive includes at some point I'm OK with this approach, as it gives us a lot more flexibility when to remove them.

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

12

33–34

Would the plan still be to remove transitive includes at some point? If not the includes will probably end up in a huge mess.

35

I think you are missing something here.

[Mordante]

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

33–34

I'm not sure. We surely need to remove them when it breaks us, like I did for <chrono>.
The big issue of removal is that may break the packagers who then need to fix it.
If it was only developers I would have less of an issue with the breakage.

We can still remove them without repercussions from C++23 and I want to look at some more TODO removals and use the granularized headers in more places. Some header include concepts or type_traits which can be minimized now.

I'm not sure whether we would get in a huge mess with the current header method.
Do you have any concrete concerns with this approach?

35

Seems I misapplied the suggested changes,thanks.

[avogelsgesang]

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

31

when do we consider a C++ version as "supported"?
As soon as we compile under that -std=c++XX flag without errors?
As soon as clang flips from -std=c++2b to -std=c++23?
As soon as we implemented all papers from that C++ version?

E.g., would we currently consider C++20 to be supported, despite not having implemented all papers, yet? If our bar is "some papers are implemented", which papers are those? Would we already consider C++23 as supported, given that we have implemented some of the C++23 papers?

72

[philnik]

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

33–34

I'm fine with it if they're removed in a release where we don't get that much done that we can ship stable. LLVM 16 will definitely contain ranges and probably format, std::pmr (PRs coming soon), maybe the PSTL (@ldionne friendly reminder to work on D103198) and more. So that's most likely not a good option, but I don't think that there will be huge additions in LLVM 17. LLVM 15 would actually have been a really good release in hind-sight. The main reason we didn't do it then was because of ranges, but that didn't actually happen.

TL;DR I don't think it would be a huge problem if people don't have a really good reason to update (not that you shouldn't keep your tools up-to-date).

My main concern is that we will have to move stuff around to implement the rest of C++17 and C++20. Having

#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 14
...
#endif

#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
...
#endif


#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
...
#endif

seems to me like a bad idea. Adding a few includes also isn't that huge of a deal. I'm not saying we should do it right now, but it might be a good idea to say: We'll remove all transitive includes in LLVM 17 (maybe?), so, vendors, please enable _LIBCPP_REMOVE_TRANSITIVE_INCLUDES for your internal testing and file bugs against any libraries/programs that break. That would give vendors lots of time to resolve any issues.

[Mordante]

Thanks for all the feedback!

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

12

I agree with removing the only but the other part but the the headers for should remain.

31

C++20 is considered supported, that's why we put ranges and format under special flags.
I left supported here intentionally since it's already defined in another part of our policy.

https://libcxx.llvm.org/UsingLibcxx.html#using-a-different-version-of-the-c-standard

33–34

First of all I hope we can clean up our transitive includes before LLVM 16. Most of our larger headers have been granularized, we need to use them were appropriate.

I initially also considered to remove them fast, but we're not sure how much of effort that will be for vendors. If they have to file bugs against hundreds of packages it may take them a lot of effort. (I expect the transitive removal of algorithm and type_traits will uncover a lot of missing includes.) So I think keeping them when it doesn't "hurt" us might be even beneficial for us. If a vendor needs to fix a lot of packages or file a lot of bugs it will take them more effort to package, which may lead them to take a longer time to adopt a new libc++.

The policy still allows us the move things around when it "hurts" us. So if implementing PMR means we need to remove additional transitive includes we still should do that, but only try to minimize that. Like in this commit I removed chrono since it makes it hard to implement format.

The end goal is to move these transitive includes to the end of the header.

So I would really like to use this policy and when it turns out it doesn't work we can revise it. We explicitly mention we're free to remove them here and in the release notes.

libcxx/docs/ReleaseNotes.rst

62–64

We kind of intentionally don't want to provide any guarantee. We still miss some C++17 features like parallel algorithms and polymorphic allocators. They may cause header cycles we want to break by removing headers.

Technically code not using the proper includes is wrong. But often you "get away" with it. But not including the proper headers makes code less portable. Some code accepted by libstdc++ will be rejected by libc++ since both libraries have different transitive includes. If you want to make sure your code doesn't miss any includes you can use _LIBCPP_REMOVE_TRANSITIVE_INCLUDES to test before it becomes an issue.

Note that in the C++ Standard there are few required headers and some might even be surprising; <regex> doesn't require <string>. Based on the interface of <regex> I'm not convinced it can be implemented (in a practical way) without providing <string>.

[Mordante]

Addresses review comments.

[philnik]

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

33–34

I get that it might be some effort for vendors to file bugs and stuff. That's why my proposal is to remove transitive includes at any point when there is a technical problem with keeping them. When we think we removed most/all the transitive includes we want to remove we tell everyone well in advance that we will remove the transitive includes in LLVM ab. If we think that we don't remove many after LLVM 16, we can say that transitive includes will be removed in LLVM 18 or whatever.

While this does result in some work IMO it's worth it. For example, including <string> already only takes 2/3 as long when adding -D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES to the command line and I'm certain this can be reduced further. Including <memory> currently adds about 100ms (the compilation took ~385ms).

[Mordante]

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

33–34

Let's discuss this further on Discord.

[jloser]

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

71

Nit: this reads a bit weird to me. Maybe s/at their/with their?

[ldionne]

I think this strikes the right balance between unblocking important work, not creating immense blockers for vendors to ship an updated libc++, and providing a way forward for the library to reduce its tech debt.

Per the policy, we might decide to do a major "let's drop all transitive includes in all standard modes" move, however that would be a bit of a project on its own and we would have to contact our main vendors to see what the impact is. This can totally be done, and I might do it a couple months down the road when things are a bit less busy, however right now I think this is the right way forward.

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

31

I'll note that we may want to revisit that definition, but it is indeed the current status quo.

33–34

The plan is definitely to eventually remove incidental transitive includes. In fact, the bigger plan would even be to have users migrate to newer standard versions, and perhaps one day drop support for older versions (we can dream, right?).

The policy is worded so that

(1) we try to minimize disruptive breakage for vendors, yet
(2) we still have the ability to remove incidental transitive includes when technically necessary (e.g. the <format> - <chrono> circular dep that brought us here).

I understand that some folks would like to have a clearer ETA for when we're going to remove those includes, however I would like to avoid committing to something specific because we still have a lot of more important things to do for the next few releases.

[philnik]

In D132284#3761464, @ldionne wrote:

I think this strikes the right balance between unblocking important work, not creating immense blockers for vendors to ship an updated libc++, and providing a way forward for the library to reduce its tech debt.

Per the policy, we might decide to do a major "let's drop all transitive includes in all standard modes" move, however that would be a bit of a project on its own and we would have to contact our main vendors to see what the impact is. This can totally be done, and I might do it a couple months down the road when things are a bit less busy, however right now I think this is the right way forward.

Then I'm happy with this patch. I just wanted to make sure that the plan is still to remove the transitive includes and this approach is just there to make it easier for us to continue implementing new features while we're working on removing the transitive includes.

[Mordante]

Thanks for all reviews!

[Mordante]

libcxx/include/algorithm

1902–1906

See D133212

libcxx/docs/DesignDocs/HeaderRemovalPolicy.rst

+=====================
+Header Removal Policy
+=====================
+
+Policy
+------
+
+Libc++ is in the process of splitting larger headers into smaller modular
+headers. This makes it possible to remove these large headers from other
+headers. For example, instead of including ``<algorithm>`` entirely it is
+possible to only include the headers for the algorithms used. When the
+Standard indirectly adds additional header includes, using the smaller headers
+aids reducing the growth of top-level headers. For example ``<atomic>`` uses
+``std::chrono::nanoseconds`` and included ``<chrono>``. In C++20 ``<chrono>``
+requires ``<format>`` which adds several other headers (like ``<string>``,
+``<optional>``, ``<tuple>``) which are not needed in ``<atomic>``.
+
+The benefit of using minimal headers is that the size of libc++'s top-level
+headers becomes smaller. This improves the compilation time when users include
+a top-level header. It also avoids header inclusion cycles and makes it easier
+to port headers to platforms with reduced functionality.
+
+A disadvantage is that users unknowingly depend on these transitive includes.
+Thus removing an include might break their build after upgrading a newer
+version of libc++. For example, ``<algorithm>`` is often forgotten but using
+algorithms will still work through those transitive includes. This problem is
+solved by modules, however in practice most people do not use modules (yet).
+
+To ease the removal of transitive includes in libc++, libc++ will remove
+unnecessary transitive includes in newly supported C++ versions. This means
+that users will have to fix their missing includes in order to upgrade to a
+newer version of the Standard. Libc++ also reserves the right to remove
+transitive includes at any other time, however new language versions will be
+used as a convenient way to perform bulk removals of transitive includes.
+
+For libc++ developers, this means that any transitive include removal must be
+guarded by something of the form:
+
+.. code-block:: cpp
+
+   #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+   #  include <algorithm>
+   #  include <iterator>
+   #  include <utility>
+   #endif
+
+When users define ``_LIBCPP_REMOVE_TRANSITIVE_INCLUDES``, libc++ will not
+include transitive headers, regardless of the language version. This can be
+useful for users to aid the transition to a newer language version, or by users
+who simply want to make sure they include what they use in their code.
+
+One of the issues for libc++ with transitive includes is that these includes
+may create dependency cycles and cause the validation script
+``libcxx/utils/graph_header_deps.py`` to have false positives. To ignore an
+include from the validation script, add a comment containing ``IGNORE-CYCLE``.
+This should only be used when there is a cycle and it has been verified it is a
+false positive.
+
+.. code-block:: cpp
+
+   #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+   #  include <chrono> // IGNORE-CYCLE due to <format>
+   #endif
+
+
+Rationale
+---------
+
+Removing headers is not only an issue for software developers, but also for
+vendors. When a vendor updates libc++ several of their upstream packages might
+fail to compile, forcing them to fix these packages or file a bug at their
+upstream packages. Usually upgrading software to a new language standard is
+done explicitly by software developers. This means they most likely will
+discover and fix the missing includes, lessening the burden for the vendors.

libcxx/docs/ReleaseNotes.rst

 - P2499R0 - ``string_view`` range constructor should be ``explicit``
 - P2417R2 - A more constexpr bitset
 
 Improvements and New Features
 -----------------------------
 
 Deprecations and Removals
 -------------------------
+- Several incidental transitive includes have been removed from libc++. Those
+  includes are removed based on the language version used. Incidental transitive
+  inclusions of the following headers have been removed:
+
+  - C++20: ``chrono``
+  - C++2b: ``algorithm``, ``array``, ``atomic``, ``bit``, ``chrono``,
+    ``climits``, ``cmath``, ``compare``, ``concepts``, ``cstdlib``,
+    ``cstring``, ``ctime``, ``exception``, ``functional``,
+    ``initializer_list``, ``iosfwd``, ``iterator``, ``memory``, ``new``,
+    ``optional``, ``ratio``, ``stdexcept``, ``tuple``, ``typeinfo``,
+    ``unordered_map``, ``utility``, ``variant``, ``vector``.
+
+  Users can also remove all incidental transitive includes by defining
+  ``_LIBCPP_REMOVE_TRANSITIVE_INCLUDES`` regardless of the language version
+  in use. Note that in the future, libc++ reserves the right to remove
+  incidental transitive includes more aggressively, in particular regardless
+  of the language version in use.
+
 
 Upcoming Deprecations and Removals
 ----------------------------------
 
 API Changes
 -----------
 - The comparison operators on ``thread::id`` are now defined as free-standing
   functions instead of as hidden friends, in conformance with the C++ standard.
   Also see `issue 56187 <https://github.com/llvm/llvm-project/issues/56187>`_.
 
 ABI Affecting Changes
 ---------------------
 
 Build System Changes
 --------------------

libcxx/docs/index.rst

.. toctree::
    DesignDocs/ABIVersioning
    DesignDocs/AtomicDesign
    DesignDocs/CapturingConfigInfo
    DesignDocs/DebugMode
    DesignDocs/ExperimentalFeatures
    DesignDocs/ExtendedCXX03Support
    DesignDocs/FeatureTestMacros
    DesignDocs/FileTimeType
+   DesignDocs/HeaderRemovalPolicy
    DesignDocs/NoexceptPolicy
    DesignDocs/ThreadingSupportAPI
    DesignDocs/UniquePtrTrivialAbi
    DesignDocs/UnspecifiedBehaviorRandomization
    DesignDocs/VisibilityMacros
 
 
 Build Bots and Test Coverage

libcxx/include/algorithm

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

libcxx/include/any

 #include <__utility/unreachable.h>
 #include <cstdlib>
 #include <initializer_list>
 #include <memory>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
-#  include <chrono>
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <chrono> // IGNORE-CYCLE due to <format>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 namespace std {
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast

libcxx/include/array

 #include <__tuple>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <iterator>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/atomic

 #include <cstring>
 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 # include <__threading_support>
 #endif
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
-#  include <chrono>
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <chrono> // IGNORE-CYCLE due to <format>
+#endif
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cmath>
+#  include <compare>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_ATOMIC_HEADER
 # error <atomic> is not implemented

libcxx/include/bit

 #include <__bit/byteswap.h>
 #include <__bits> // __libcpp_clz
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <limits>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iosfwd>
 #endif
 
 #if defined(_LIBCPP_COMPILER_MSVC)
 #  include <intrin.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/charconv

 #include <__utility/unreachable.h>
 #include <cmath> // for log2f
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <type_traits>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iosfwd>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/coroutine

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__coroutine/coroutine_handle.h>
 #include <__coroutine/coroutine_traits.h>
 #include <__coroutine/noop_coroutine_handle.h>
 #include <__coroutine/trivial_awaitables.h>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iosfwd>
 #endif
 
 // standard-mandated includes
 #include <compare>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_COROUTINE

libcxx/include/deque

 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/experimental/simd

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/operations.h>
 #include <array>
 #include <cstddef>
 #include <experimental/__config>
 #include <tuple>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/experimental/unordered_map

 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <unordered_map>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <array>
 #  include <bit>
 #  include <functional>
 #  include <vector>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/ext/hash_map

 #include <__config>
 #include <__hash_table>
 #include <algorithm>
 #include <ext/__hash>
 #include <functional>
 #include <stdexcept>
 #include <type_traits>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #endif
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
 #else
 #   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>

libcxx/include/ext/hash_set

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
 #include <algorithm>
 #include <ext/__hash>
 #include <functional>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #endif
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
 #else
 #   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>

libcxx/include/forward_list

 #include <__iterator/next.h>
 #include <__memory/swap_allocator.h>
 #include <__utility/forward.h>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/functional

 #include <concepts>
 #include <exception>
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <utility>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

 #include <__utility/move.h>
 #include <exception>
 #include <memory>
 #include <mutex>
 #include <system_error>
 #include <thread>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
-#  include <chrono>
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <chrono> // IGNORE-CYCLE due to <format>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 # error "<future> is not supported since libc++ has been configured without support for threads."

libcxx/include/iterator

 #include <__memory/pointer_traits.h>
 #include <compare>
 #include <concepts> // Mandated by the Standard.
 #include <cstddef>
 #include <initializer_list>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <exception>
 #  include <new>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_ITERATOR

libcxx/include/list

 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/locale

 #include <cstdlib>
 #include <ctime>
 #include <ios>
 #include <limits>
 #include <memory>
 #include <streambuf>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #endif
 
 #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 // Most unix variants have catopen.  These are the specific ones that don't.
 #  if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)
 #    define _LIBCPP_HAS_CATOPEN 1
 #    include <nl_types.h>

libcxx/include/map

 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <__utility/swap.h>
 #include <memory>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/memory

 #include <iosfwd>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/mutex

 #include <__utility/forward.h>
 #include <cstdint>
 #include <memory>
 #ifndef _LIBCPP_CXX03_LANG
 # include <tuple>
 #endif
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/numeric

 #include <__numeric/iota.h>
 #include <__numeric/midpoint.h>
 #include <__numeric/partial_sum.h>
 #include <__numeric/reduce.h>
 #include <__numeric/transform_exclusive_scan.h>
 #include <__numeric/transform_inclusive_scan.h>
 #include <__numeric/transform_reduce.h>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_numeric>
 #endif
 
 #endif // _LIBCPP_NUMERIC

libcxx/include/optional

 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <chrono> // IGNORE-CYCLE due to <format>
+#endif
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
-#  include <chrono>
 #  include <climits>
 #  include <concepts>
 #  include <ctime>
 #  include <iterator>
 #  include <memory>
 #  include <ratio>
 #  include <tuple>
 #  include <typeinfo>

libcxx/include/ostream

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <bitset>
 #include <ios>
 #include <locale>
 #include <streambuf>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/random

 #include <__random/student_t_distribution.h>
 #include <__random/subtract_with_carry_engine.h>
 #include <__random/uniform_int_distribution.h>
 #include <__random/uniform_random_bit_generator.h>
 #include <__random/uniform_real_distribution.h>
 #include <__random/weibull_distribution.h>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #endif
 
 // standard-mandated includes
 #include <initializer_list>
 
 #include <cmath>       // for backward compatibility; TODO remove it
 #include <cstddef>     // for backward compatibility; TODO remove it

libcxx/include/regex

 #include <__utility/swap.h>
 #include <deque>
 #include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iterator>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>

libcxx/include/set

 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>

libcxx/include/span

 #include <__ranges/size.h>
 #include <__utility/forward.h>
 #include <array>        // for array
 #include <cstddef>      // for byte
 #include <limits>
 #include <type_traits>  // for remove_cv, etc
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>

libcxx/include/stack

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

libcxx/include/string

 #include <string_view>
 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #  include <new>
 #  include <typeinfo>
 #  include <utility>
 #  include <vector>
 #endif

libcxx/include/string_view

 #include <__ranges/size.h>
 #include <__string/char_traits.h>
 #include <iosfwd>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/thread

 #include <cstddef>
 #include <iosfwd>
 #include <memory>
 #include <system_error>
 #include <tuple>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
-#  include <chrono>
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <chrono> // IGNORE-CYCLE due to <format>
+#endif
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #endif
 
 // standard-mandated includes
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/tuple

 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <exception>
 #  include <iosfwd>
 #  include <new>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 // standard-mandated includes

libcxx/include/typeindex

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/unary_function.h>
 #include <typeinfo>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iosfwd>
 #  include <new>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 #include <compare>
 

libcxx/include/unordered_map

 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <stdexcept>
 #include <tuple>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <bit>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/include/unordered_set

 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <functional>
 #  include <iterator>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>

libcxx/include/utility

 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
 #include <__utility/to_underlying.h>
 #include <__utility/transaction.h>
 #include <__utility/unreachable.h>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iosfwd>
 #endif
 
 // standard-mandated includes
 #include <compare>
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_UTILITY

libcxx/include/valarray

 #include <__memory/uninitialized_algorithms.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cmath>
 #include <cstddef>
 #include <new>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <functional>
 #endif
 
 // standard-mandated includes
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/variant

 #include <exception>
 #include <initializer_list>
 #include <limits>
 #include <new>
 #include <tuple>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/vector

 #include <cstring>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>
 #include <memory>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
-#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 
 // [iterator.range]

libcxx/test/libcxx/transitive_includes/cxx20/expected.algorithm

 algorithm
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.any

 any
 atomic
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.array

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.atomic

 atomic
-chrono
 climits
 cmath
 compare
 cstddef
 cstdint
 cstring
 ctime
 iosfwd
 limits
 ratio
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx20/expected.barrier

 atomic
 barrier
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.bitset

 algorithm
 array
 atomic
 bit
 bitset
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.ccomplex

 algorithm
 array
 atomic
 bit
 bitset
 ccomplex
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 complex
 concepts
 cstdarg
 cstddef
 cstdint

libcxx/test/libcxx/transitive_includes/cxx20/expected.codecvt

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 codecvt
 compare
 concepts
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.complex

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 complex
 concepts
 cstdarg
 cstddef
 cstdint

libcxx/test/libcxx/transitive_includes/cxx20/expected.condition_variable

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 condition_variable
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.ctgmath

 algorithm
 array
 atomic
 bit
 bitset
 ccomplex
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 complex
 concepts
 cstdarg
 cstddef
 cstdint

libcxx/test/libcxx/transitive_includes/cxx20/expected.deque

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_algorithm

 algorithm
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_coroutine

 atomic
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_deque

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_forward_list

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_functional

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_list

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_map

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_memory_resource

 atomic
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_regex

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_set

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_simd

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_string

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_unordered_map

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_unordered_set

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.experimental_vector

 algorithm
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.ext_hash_map

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.ext_hash_set

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.filesystem

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.format

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
 charconv
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.forward_list

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.fstream

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.functional

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.future

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.iomanip

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.ios

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.iostream

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.istream

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.latch

 atomic
-chrono
 climits
 cmath
 compare
 cstddef
 cstdint
 cstring
 ctime
 iosfwd
 latch
 limits
 ratio
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx20/expected.list

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.locale

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.map

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.memory

 atomic
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.mutex

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.numeric

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.optional

 atomic
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.ostream

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.queue

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.random

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.ranges

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.regex

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.scoped_allocator

 atomic
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.semaphore

 atomic
-chrono
 climits
 cmath
 compare
 cstddef
 cstdint
 cstring
 ctime
 iosfwd
 limits
 ratio
 semaphore
 type_traits
 version

libcxx/test/libcxx/transitive_includes/cxx20/expected.set

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.shared_mutex

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.span

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.sstream

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.stack

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.streambuf

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.string

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.string_view

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.strstream

 algorithm
 array
 atomic
 bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio

libcxx/test/libcxx/transitive_includes/cxx20/expected.system_error

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.thread

 algorithm
 array
 atomic
 bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib

libcxx/test/libcxx/transitive_includes/cxx20/expected.unordered_map

 algorithm
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.unordered_set

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.valarray

 algorithm
 array
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

libcxx/test/libcxx/transitive_includes/cxx20/expected.vector

 algorithm
 atomic
 bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring

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

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

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

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.array

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.atomic

 atomic
-chrono
 climits
-cmath
-compare
 cstddef
 cstdint
 cstring
 ctime
 iosfwd
 limits
 ratio
 type_traits
 version

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

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.bit

 bit
 cstddef
 cstdint
 cstdlib
-iosfwd
 limits
 type_traits
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 ccomplex
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 complex
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 sstream
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.charconv

 cerrno
 charconv
 cmath
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 initializer_list
-iosfwd
 limits
 type_traits
 version

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 codecvt
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 mutex
 new
-optional
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 complex
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 sstream
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 condition_variable
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.coroutine

 cmath
 compare
 coroutine
 cstddef
 cstdint
 cstring
-iosfwd
 limits
 type_traits
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 ccomplex
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 complex
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctgmath
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 sstream
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

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

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

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

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

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

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

-algorithm
-array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 deque
 exception
 experimental/deque
 experimental/memory_resource
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
-unordered_map
 utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/forward_list
 experimental/memory_resource
 experimental/utility
 forward_list
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
-unordered_map
 utility
-variant
-vector
 version

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

-algorithm
 array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/functional
 functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
 optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 unordered_map
-utility
-variant
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_iterator

 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 exception
 experimental/iterator
 initializer_list
 iosfwd
 iterator
 limits
 new
 tuple
 type_traits
-typeinfo
-utility
 variant
 version

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

-algorithm
-array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/list
 experimental/memory_resource
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 list
 memory
 new
-optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
-unordered_map
 utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/map
 experimental/memory_resource
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 map
 memory
 new
 optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
-unordered_map
 utility
-variant
-vector
 version

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

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

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 deque
 exception
 experimental/memory_resource
 experimental/regex
 experimental/string
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 mutex
 new
-optional
 ratio
 regex
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
 utility
-variant
 vector
 version

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

-algorithm
-array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/memory_resource
 experimental/set
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
 optional
 ratio
 set
 stdexcept
 tuple
 type_traits
 typeinfo
-unordered_map
 utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_simd

-algorithm
 array
-atomic
-bit
-chrono
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
-cstring
-ctime
 exception
 experimental/simd
-functional
 initializer_list
 iosfwd
-iterator
 limits
-memory
-new
-optional
-ratio
 stdexcept
 tuple
 type_traits
-typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 experimental/memory_resource
 experimental/string
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
-unordered_map
 utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/memory_resource
 experimental/unordered_map
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
 optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
 unordered_map
 utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 ctime
 exception
 experimental/memory_resource
 experimental/unordered_set
 experimental/utility
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
 optional
 ratio
 stdexcept
 tuple
 type_traits
 typeinfo
-unordered_map
 unordered_set
 utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.experimental_utility

 cmath
 compare
 cstddef
 cstdint
 cstdlib
 experimental/utility
 initializer_list
-iosfwd
 limits
 type_traits
 utility
 version

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

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

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

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 ext/hash_map
 functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
 optional
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
 unordered_map
-utility
-variant
 vector
 version

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

 algorithm
 array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 ext/hash_set
 functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
 optional
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
 unordered_map
-utility
-variant
 vector
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 filesystem
-functional
 initializer_list
 iomanip
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
 array
 atomic
 bit
 cctype
 cerrno
 charconv
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 format
-functional
 initializer_list
 ios
 iosfwd
-iterator
 limits
 locale
 memory
 mutex
 new
 optional
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

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

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
 filesystem
 fstream
-functional
 initializer_list
 iomanip
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

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

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 future
 initializer_list
 iosfwd
-iterator
 limits
 memory
 mutex
 new
-optional
 ratio
 stdexcept
 string
 string_view
 system_error
 thread
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iomanip
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
-iterator
 limits
 memory
 mutex
 new
-optional
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
 iostream
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.iterator

 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
 exception
 initializer_list
 iosfwd
 iterator
 limits
 new
 tuple
 type_traits
-typeinfo
-utility
 variant
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.latch

 atomic
-chrono
 climits
-cmath
-compare
 cstddef
 cstdint
 cstring
 ctime
 iosfwd
 latch
 limits
 ratio
 type_traits
 version

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

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

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.memory

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

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 mutex
 new
-optional
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.numeric

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.optional

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

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

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

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

-algorithm
-array
 atomic
 bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
 numeric
-optional
 random
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
 vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.ranges

-algorithm
 array
-atomic
-bit
-chrono
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdlib
 cstring
-ctime
 exception
-functional
 initializer_list
 iosfwd
 iterator
 limits
-memory
 new
 optional
 ranges
-ratio
 span
 stdexcept
 tuple
 type_traits
-typeinfo
-unordered_map
-utility
 variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 deque
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 mutex
 new
-optional
 ratio
 regex
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
 vector
 version

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

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.semaphore

 atomic
-chrono
 climits
-cmath
-compare
 cstddef
 cstdint
 cstring
 ctime
 iosfwd
 limits
 ratio
 semaphore
 type_traits
 version

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

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

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 shared_mutex
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.span

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

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 sstream
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

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

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
-iterator
 limits
 memory
 mutex
 new
-optional
 ratio
 stdexcept
 streambuf
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 cctype
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 string
 string_view
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.string_view

-algorithm
-array
-atomic
-bit
 cctype
-chrono
-climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
-ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
-memory
-new
-optional
-ratio
 stdexcept
 string_view
-tuple
 type_traits
-typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 bitset
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstdarg
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 ios
 iosfwd
 istream
-iterator
 limits
 locale
 memory
 mutex
 new
-optional
 ostream
 ratio
 stdexcept
 streambuf
 string
 string_view
 strstream
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 string
 string_view
 system_error
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

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

-algorithm
-array
 atomic
-bit
 cctype
 cerrno
-chrono
 climits
 cmath
 compare
 concepts
 cstddef
 cstdint
 cstdio
 cstdlib
 cstring
 ctime
 cwchar
 cwctype
 exception
-functional
 initializer_list
 iosfwd
-iterator
 limits
 memory
 new
-optional
 ratio
 stdexcept
 string
 string_view
 system_error
 thread
 tuple
 type_traits
 typeinfo
-unordered_map
-utility
-variant
-vector
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.tuple

 cmath
 compare
 cstddef
 cstdint
-cstdlib
-exception
-initializer_list
-iosfwd
 limits
-new
 tuple
 type_traits
-typeinfo
-utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.typeindex

 cmath
 compare
 cstddef
 cstdint
 cstdlib
 exception
-initializer_list
-iosfwd
 limits
-new
 type_traits
 typeindex
 typeinfo
-utility
 version

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

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

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

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.utility

 cmath
 compare
 cstddef
 cstdint
 cstdlib
 initializer_list
-iosfwd
 limits
 type_traits
 utility
 version

libcxx/test/libcxx/transitive_includes/cxx2b/expected.valarray

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

libcxx/test/libcxx/transitive_includes/cxx2b/expected.variant

 cmath
 compare
 cstddef
 cstdint
 cstdlib
 cstring
 exception
 initializer_list
-iosfwd
 limits
 new
 tuple
 type_traits
-typeinfo
-utility
 variant
 version

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

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

libcxx/utils/graph_header_deps.py

def build_file_entry(fname, options):
     with open(fname, 'r', encoding='utf-8') as f:
         for line in f.readlines():
             linecount += 1
             m = re.match(r'\s*#\s*include\s+"([^"]*)"', line)
             if m is not None:
                 local_includes.append(m.group(1))
             m = re.match(r'\s*#\s*include\s+<([^>]*)>', line)
             if m is not None:
+                # Since libc++ keeps transitive includes guarded by the
+                # language version some cycles can be ignored. For example
+                # before C++20 several headers included <chrono> without using
+                # it. In C++20 <chrono> conditionally includes <format> in
+                # C++20. This causes multiple cycles in this script that can't
+                # happen in practice. Since the script uses a regex instead of
+                # a parser use a magic word.
+                if re.search(r'IGNORE-CYCLE', line) is None:
                     system_includes.append(m.group(1))
 
     fully_qualified_includes = [
         locate_header_file(h, options.search_dirs)
         for h in system_includes
     ] + [
         locate_header_file(h, os.path.dirname(fname))
         for h in local_includes
     ]