This is an archive of the discontinued LLVM Phabricator instance.

Differential D128661

[libc++] Re-add transitive includes that had been removed since LLVM 14
ClosedPublic

Authored by ldionne on Jun 27 2022, 9:10 AM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rGde4a57cb21a1: [libc++] Re-add transitive includes that had been removed since LLVM 14
Summary

This commit re-adds transitive includes that had been removed by
4cd04d1687f1, c36870c8e79c, a83f4b9cda57, 1458458b558d, 2e2f3158c604,
and 489637e66dd3. This should cover all the includes that had been
removed since LLVM 14 and that would contribute to breaking user code
when releasing LLVM 15.

It is possible to disable the inclusion of these headers by defining
_LIBCPP_REMOVE_TRANSITIVE_INCLUDES. The intent is that vendors will
enable that macro and start fixing downstream issues immediately. We
can then remove the macro (and the transitive includes) by default in
a future release. That way, we will break users only once by removing
transitive includes in bulk instead of doing it bit by bit a every
release, which is more disruptive for users.

Note 1: The set of headers to re-add was found by re-generating the

transitive include test on a checkout of release/14.x, which
provided the list of all transitive includes we used to provide.

Note 2: Several includes of <vector>, <optional>, <array> and <unordered_map>

have been added in this commit. These transitive inclusions were
added when we implemented boyer_moore_searcher in <functional>.

Note 3: This is a best effort patch to try and resolve downstream breakage

caused since branching LLVM 14. I wasn't able to perfectly mirror
transitive includes in LLVM 14 for a few headers like <unordered_map>
and <optional> due to circular dependencies.

Diff Detail

Event Timeline

ldionne created this revision.Jun 27 2022, 9:10 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 27 2022, 9:10 AM
Herald added subscribers: miyuki, arphaman. · View Herald Transcript
ldionne requested review of this revision.Jun 27 2022, 9:10 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 27 2022, 9:10 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
ldionne added inline comments.Jun 27 2022, 9:12 AM
libcxx/include/random
1728

Note that I have a follow-up patch ready to go that consolidates all those into the _LIBCPP_REMOVE_TRANSITIVE_INCLUDES block (in all headers).

Harbormaster completed remote builds in B172220: Diff 440257.Jun 27 2022, 9:32 AM
Mordante added a subscriber: Mordante.Jun 27 2022, 9:56 AM

A said before I'm not completely happy we have to take this approach, but I understand why it's important for some users of libc++. So I don't have objections against this approach. But I really would like the CI to test the new macro.

libcxx/docs/ReleaseNotes.rst
103

Can we use _LIBCPP_REMOVE_TRANSITIVE_INCLUDES in the CI, that way we know that removing the includes guarded by this macro doesn't bit rot.

ldionne updated this revision to Diff 440313.Jun 27 2022, 10:53 AM
ldionne marked an inline comment as done.

Add CI job.

Herald added subscribers: arichardson, mgorny. · View Herald TranscriptJun 27 2022, 10:53 AM
philnik added a subscriber: philnik.Jun 27 2022, 11:06 AM
philnik added inline comments.
libcxx/cmake/caches/Generic-no-transitive-includes.cmake
1

I think the right way would be to remove the transitive includes by default in the CI and disable them in one runner.

libcxx/include/algorithm
1263–1268

I would put the includes below the standard-mandated ones, but I guess it doesn't make a big difference, since we plan to remove them anyways.

Harbormaster completed remote builds in B172263: Diff 440313.Jun 27 2022, 11:17 AM
ldionne updated this revision to Diff 440375.Jun 27 2022, 1:50 PM

Fix circular dependency issues, reduce the difference with LLVM 14.

libcxx/cmake/caches/Generic-no-transitive-includes.cmake
1

IMO the CI should mirror the state of the library as we're going to release/ship it. It makes it more likely that we'll catch errors that we would otherwise ship. Since we want to ship with the transitive includes enabled by default, all CI jobs should have them by default.

The added CI job only exists to ensure that the code doesn't bit rot and that we can remove the transitive includes in the future without additional work.

libcxx/include/algorithm
1263–1268

I'll keep as-is, because changing this would be a sizeable amount of work for little benefit, especially since I have other follow-up patches locally that would need a ton of rebasing. I'll be happy to do it if there's a technical reason to, but I can't think of one right now. LMK if you do.

philnik added inline comments.Jun 27 2022, 2:33 PM
libcxx/cmake/caches/Generic-no-transitive-includes.cmake
1

I would normally agree, but in this case I don't see how it could break anything. We have tests to ensure that we can include everything in a single TU, a Modules build and more to ensure all the includes works together properly. I would see it the way same as _LIBCPP_HAS_NO_INCOMPLETE_RANGES - we work on it and check it in the CI, but we don't ship it yet (plus we have a CI job for the "disabled" configuration).

libcxx/include/algorithm
1263–1268

It's just preference - the stuff we don't want to include shouldn't provide dependencies for other headers. This is of course a moot point with a modules build. So yeah, I don't care that much (especially if it would cause a lot of work for you).

Harbormaster completed remote builds in B172308: Diff 440375.Jun 27 2022, 3:52 PM
ldionne accepted this revision.Jun 27 2022, 7:18 PM
ldionne added inline comments.
libcxx/cmake/caches/Generic-no-transitive-includes.cmake
1

Yeah, I can see the parallel with _LIBCPP_HAS_NO_INCOMPLETE_RANGES, however I do think that this option leads to complexity and brittleness (for example we have to turn it ON on our release branches while it's OFF on main). Concretely, I think having a CMake cache for LLVM releases would solve most of my concerns about this, except for the need to have a CMake-level configuration option for this knob: If we change it to _LIBCPP_ENABLE_BACKWARDS_COMPAT_TRANSITIVE_INCLUDES and make it undefined by default, we'll need a setting in __config_site to define it by default for LLVM releases and for most vendors. I'd like to avoid this additional complexity.

Also, to further make a distinction with _LIBCPP_HAS_NO_INCOMPLETE_RANGES, once we move to -funstable, _LIBCPP_HAS_NO_INCOMPLETE_RANGES will be disabled by default (unlike right now), so it will be consistent with the approach proposed here. I'll land this patch now because I want to see how it affects downstreams immediately, but I don't consider this discussion to be closed -- I'm open to discussion on the default ON/OFF.

This revision is now accepted and ready to land.Jun 27 2022, 7:18 PM
Closed by commit rGde4a57cb21a1: [libc++] Re-add transitive includes that had been removed since LLVM 14 (authored by ldionne). · Explain WhyJun 27 2022, 7:19 PM
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rGde4a57cb21a1: [libc++] Re-add transitive includes that had been removed since LLVM 14.
sberg added a subscriber: sberg.Jun 27 2022, 11:43 PM
This comment was removed by sberg.
sberg added a comment.Jun 27 2022, 11:59 PM

[sorry for the noise; my previous, removed comment was due to some local modifications on my end]

Revision Contents

PathSize
libcxx/
cmake/
caches/
2 lines
docs/
17 lines
include/
7 lines
4 lines
6 lines
4 lines
4 lines
4 lines
4 lines
5 lines
experimental/
4 lines
4 lines
4 lines
5 lines
5 lines
8 lines
ext/
4 lines
4 lines
5 lines
4 lines
4 lines
7 lines
5 lines
4 lines
6 lines
5 lines
4 lines
5 lines
14 lines
4 lines
4 lines
4 lines
5 lines
5 lines
4 lines
8 lines
5 lines
5 lines
8 lines
6 lines
4 lines
5 lines
4 lines
5 lines
5 lines
6 lines
test/
libcxx/
5 lines
transitive_includes/
9 lines
4 lines
19 lines
3 lines
4 lines
1 line
11 lines
11 lines
1 line
11 lines
11 lines
11 lines
1 line
11 lines
11 lines
9 lines
11 lines
10 lines
10 lines
6 lines
2 lines
10 lines
9 lines
3 lines
29 lines
9 lines
9 lines
18 lines
10 lines
8 lines
9 lines
1 line
9 lines
4 lines
4 lines
11 lines
8 lines
11 lines
11 lines
6 lines
11 lines
11 lines
11 lines
11 lines
11 lines
2 lines
3 lines
11 lines
11 lines
10 lines
4 lines
11 lines
26 lines
11 lines
11 lines
10 lines
9 lines
13 lines
10 lines
4 lines
3 lines
10 lines
11 lines
19 lines
11 lines
11 lines
11 lines
11 lines
19 lines
11 lines
11 lines
11 lines
7 lines
4 lines
4 lines
10 lines
1 line
19 lines
3 lines
10 lines
utils/
ci/
15 lines
5 lines
libcxx/
test/
9 lines

Diff 440313

libcxx/cmake/caches/Generic-no-transitive-includes.cmake

  • This file was added.
set(LIBCXX_TEST_PARAMS "enable_transitive_includes=False" CACHE STRING "")
philnikUnsubmitted
Not Done
ReplyInline Actions

I think the right way would be to remove the transitive includes by default in the CI and disable them in one runner.

philnik: I think the right way would be to remove the transitive includes by default in the CI and…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

IMO the CI should mirror the state of the library as we're going to release/ship it. It makes it more likely that we'll catch errors that we would otherwise ship. Since we want to ship with the transitive includes enabled by default, all CI jobs should have them by default.

The added CI job only exists to ensure that the code doesn't bit rot and that we can remove the transitive includes in the future without additional work.

ldionne: IMO the CI should mirror the state of the library as we're going to release/ship it. It makes…
philnikUnsubmitted
Not Done
ReplyInline Actions

I would normally agree, but in this case I don't see how it could break anything. We have tests to ensure that we can include everything in a single TU, a Modules build and more to ensure all the includes works together properly. I would see it the way same as _LIBCPP_HAS_NO_INCOMPLETE_RANGES - we work on it and check it in the CI, but we don't ship it yet (plus we have a CI job for the "disabled" configuration).

philnik: I would normally agree, but in this case I don't see how it could break anything. We have tests…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Yeah, I can see the parallel with _LIBCPP_HAS_NO_INCOMPLETE_RANGES, however I do think that this option leads to complexity and brittleness (for example we have to turn it ON on our release branches while it's OFF on main). Concretely, I think having a CMake cache for LLVM releases would solve most of my concerns about this, except for the need to have a CMake-level configuration option for this knob: If we change it to _LIBCPP_ENABLE_BACKWARDS_COMPAT_TRANSITIVE_INCLUDES and make it undefined by default, we'll need a setting in __config_site to define it by default for LLVM releases and for most vendors. I'd like to avoid this additional complexity.

Also, to further make a distinction with _LIBCPP_HAS_NO_INCOMPLETE_RANGES, once we move to -funstable, _LIBCPP_HAS_NO_INCOMPLETE_RANGES will be disabled by default (unlike right now), so it will be consistent with the approach proposed here. I'll land this patch now because I want to see how it affects downstreams immediately, but I don't consider this discussion to be closed -- I'm open to discussion on the default ON/OFF.

ldionne: Yeah, I can see the parallel with `_LIBCPP_HAS_NO_INCOMPLETE_RANGES`, however I do think that…
set(LIBCXXABI_TEST_PARAMS "${LIBCXX_TEST_PARAMS}" CACHE STRING "")

libcxx/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines- The ``_LIBCPP_ABI_UNSTABLE`` macro has been removed in favour of setting
they were not supposed to set ``_LIBCPP_ABI_UNSTABLE`` manually, however we they were not supposed to set ``_LIBCPP_ABI_UNSTABLE`` manually, however we
still feel that it is worth mentioning in the release notes in case some users still feel that it is worth mentioning in the release notes in case some users
had been doing it. had been doing it.
- The header ``<experimental/filesystem>`` has been removed. Instead, use - The header ``<experimental/filesystem>`` has been removed. Instead, use
``<filesystem>`` header. The associated macro ``<filesystem>`` header. The associated macro
``_LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM`` has also been removed. ``_LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM`` has also been removed.
- Some libc++ headers no longer transitively include all of: - Libc++ is getting ready to remove unnecessary transitive inclusions. This may
- ``<algorithm>`` break your code in the future. To future-proof your code to these removals,
- ``<chrono>`` please compile your code with ``_LIBCPP_REMOVE_TRANSITIVE_INCLUDES`` defined
- ``<exception>`` and fix any compilation error resulting from missing includes.
MordanteUnsubmitted
Done
ReplyInline Actions

Can we use _LIBCPP_REMOVE_TRANSITIVE_INCLUDES in the CI, that way we know that removing the includes guarded by this macro doesn't bit rot.

Mordante: Can we use `_LIBCPP_REMOVE_TRANSITIVE_INCLUDES` in the CI, that way we know that removing the…
- ``<functional>``
- ``<iterator>``
- ``<new>``
- ``<typeinfo>``
- ``<utility>``
If, after updating libc++, you see compiler errors related to missing declarations
in namespace ``std``, it might be because one of your source files now needs to
include one or more of the headers listed above.
- The integer distributions ``binomial_distribution``, ``discrete_distribution``, - The integer distributions ``binomial_distribution``, ``discrete_distribution``,
``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``, ``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``,
and ``uniform_int_distribution`` now conform to the Standard by rejecting and ``uniform_int_distribution`` now conform to the Standard by rejecting
template parameter types other than ``short``, ``int``, ``long``, ``long long``, template parameter types other than ``short``, ``int``, ``long``, ``long long``,
(as an extension) ``__int128_t``, and the unsigned versions thereof. (as an extension) ``__int128_t``, and the unsigned versions thereof.
In particular, ``uniform_int_distribution<int8_t>`` is no longer supported. In particular, ``uniform_int_distribution<int8_t>`` is no longer supported.
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

libcxx/include/algorithm

Show First 20 Lines • Show All 1,254 Lines • ▼ Show 20 Lines
#include <__algorithm/stable_sort.h> #include <__algorithm/stable_sort.h>
#include <__algorithm/swap_ranges.h> #include <__algorithm/swap_ranges.h>
#include <__algorithm/transform.h> #include <__algorithm/transform.h>
#include <__algorithm/unique.h> #include <__algorithm/unique.h>
#include <__algorithm/unique_copy.h> #include <__algorithm/unique_copy.h>
#include <__algorithm/unwrap_iter.h> #include <__algorithm/unwrap_iter.h>
#include <__algorithm/upper_bound.h> #include <__algorithm/upper_bound.h>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <chrono>
# include <functional>
# include <iterator>
# include <utility>
#endif
philnikUnsubmitted
Not Done
ReplyInline Actions

I would put the includes below the standard-mandated ones, but I guess it doesn't make a big difference, since we plan to remove them anyways.

philnik: I would put the includes below the standard-mandated ones, but I guess it doesn't make a big…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

I'll keep as-is, because changing this would be a sizeable amount of work for little benefit, especially since I have other follow-up patches locally that would need a ton of rebasing. I'll be happy to do it if there's a technical reason to, but I can't think of one right now. LMK if you do.

ldionne: I'll keep as-is, because changing this would be a sizeable amount of work for little benefit…
philnikUnsubmitted
Not Done
ReplyInline Actions

It's just preference - the stuff we don't want to include shouldn't provide dependencies for other headers. This is of course a moot point with a modules build. So yeah, I don't care that much (especially if it would cause a lot of work for you).

philnik: It's just preference - the stuff we don't want to include shouldn't provide dependencies for…
// standard-mandated includes // standard-mandated includes
#include <initializer_list> #include <initializer_list>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
# include <__pstl_algorithm> # include <__pstl_algorithm>
#endif #endif
#endif // _LIBCPP_ALGORITHM #endif // _LIBCPP_ALGORITHM

libcxx/include/any

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
#include <__utility/unreachable.h> #include <__utility/unreachable.h>
#include <cstdlib> #include <cstdlib>
#include <initializer_list> #include <initializer_list>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <typeinfo> #include <typeinfo>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <chrono>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
namespace std { namespace std {
class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
{ {
public: public:
▲ Show 20 Lines • Show All 590 Lines • Show Last 20 Lines

libcxx/include/array

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
#include <__tuple> #include <__tuple>
#include <__utility/integer_sequence.h> #include <__utility/integer_sequence.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/unreachable.h> #include <__utility/unreachable.h>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <iterator>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 404 Lines • Show Last 20 Lines

libcxx/include/atomic

Show First 20 Lines • Show All 528 Lines • ▼ Show 20 Lines
#include <cstring> #include <cstring>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_HAS_NO_THREADS #ifndef _LIBCPP_HAS_NO_THREADS
# include <__threading_support> # include <__threading_support>
#endif #endif
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <chrono>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#ifdef _LIBCPP_HAS_NO_ATOMIC_HEADER #ifdef _LIBCPP_HAS_NO_ATOMIC_HEADER
# error <atomic> is not implemented # error <atomic> is not implemented
#endif #endif
#ifdef kill_dependency #ifdef kill_dependency
▲ Show 20 Lines • Show All 2,158 Lines • Show Last 20 Lines

libcxx/include/bit

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
#include <__bit/byteswap.h> #include <__bit/byteswap.h>
#include <__bits> // __libcpp_clz #include <__bits> // __libcpp_clz
#include <__concepts/arithmetic.h> #include <__concepts/arithmetic.h>
#include <__config> #include <__config>
#include <limits> #include <limits>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iosfwd>
#endif
#if defined(__IBMCPP__) #if defined(__IBMCPP__)
# include "__support/ibm/support.h" # include "__support/ibm/support.h"
#endif #endif
#if defined(_LIBCPP_COMPILER_MSVC) #if defined(_LIBCPP_COMPILER_MSVC)
# include <intrin.h> # include <intrin.h>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

libcxx/include/charconv

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
#include <__utility/unreachable.h> #include <__utility/unreachable.h>
#include <cmath> // for log2f #include <cmath> // for log2f
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <limits> #include <limits>
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iosfwd>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
▲ Show 20 Lines • Show All 651 Lines • Show Last 20 Lines

libcxx/include/coroutine

Show All 40 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__coroutine/coroutine_handle.h> #include <__coroutine/coroutine_handle.h>
#include <__coroutine/coroutine_traits.h> #include <__coroutine/coroutine_traits.h>
#include <__coroutine/noop_coroutine_handle.h> #include <__coroutine/noop_coroutine_handle.h>
#include <__coroutine/trivial_awaitables.h> #include <__coroutine/trivial_awaitables.h>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iosfwd>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_COROUTINE #endif // _LIBCPP_COROUTINE

libcxx/include/deque

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <limits> #include <limits>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 2,865 Lines • Show Last 20 Lines

libcxx/include/experimental/coroutine

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
#include <__functional/hash.h> #include <__functional/hash.h>
#include <__functional/operations.h> #include <__functional/operations.h>
#include <cstddef> #include <cstddef>
#include <experimental/__config> #include <experimental/__config>
#include <memory> // for hash<T*> #include <memory> // for hash<T*>
#include <new> #include <new>
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <functional>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES #ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

libcxx/include/experimental/functional

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
#include <__memory/uses_allocator.h> #include <__memory/uses_allocator.h>
#include <array> #include <array>
#include <experimental/__config> #include <experimental/__config>
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_LFTS
▲ Show 20 Lines • Show All 356 Lines • Show Last 20 Lines

libcxx/include/experimental/memory_resource

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
#include <experimental/__config> #include <experimental/__config>
#include <experimental/__memory> #include <experimental/__memory>
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <new> #include <new>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <utility>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
▲ Show 20 Lines • Show All 332 Lines • Show Last 20 Lines

libcxx/include/experimental/propagate_const

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__functional/operations.h> #include <__functional/operations.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <experimental/__config> #include <experimental/__config>
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <functional>
# include <utility>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
_LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
▲ Show 20 Lines • Show All 455 Lines • Show Last 20 Lines

libcxx/include/experimental/simd

Show First 20 Lines • Show All 650 Lines • ▼ Show 20 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__functional/operations.h> #include <__functional/operations.h>
#include <array> #include <array>
#include <cstddef> #include <cstddef>
#include <experimental/__config> #include <experimental/__config>
#include <tuple> #include <tuple>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <functional>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
▲ Show 20 Lines • Show All 911 Lines • Show Last 20 Lines

libcxx/include/experimental/unordered_map

Show All 39 Lines
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <experimental/__config> #include <experimental/__config>
#include <experimental/memory_resource> #include <experimental/memory_resource>
#include <unordered_map> #include <unordered_map>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <array>
# include <bit>
# include <functional>
# include <vector>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
template <class _Key, class _Value, template <class _Key, class _Value,
class _Hash = hash<_Key>, class _Pred = equal_to<_Key>> class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
Show All 11 Lines

libcxx/include/ext/hash_map

Show First 20 Lines • Show All 204 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <__hash_table> #include <__hash_table>
#include <algorithm> #include <algorithm>
#include <ext/__hash> #include <ext/__hash>
#include <functional> #include <functional>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
#endif
#if defined(__DEPRECATED) && __DEPRECATED #if defined(__DEPRECATED) && __DEPRECATED
#if defined(_LIBCPP_WARNING) #if defined(_LIBCPP_WARNING)
_LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map>") _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map>")
#else #else
# warning Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map> # warning Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map>
#endif #endif
#endif #endif
▲ Show 20 Lines • Show All 766 Lines • Show Last 20 Lines

libcxx/include/ext/hash_set

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__hash_table> #include <__hash_table>
#include <algorithm> #include <algorithm>
#include <ext/__hash> #include <ext/__hash>
#include <functional> #include <functional>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
#endif
#if defined(__DEPRECATED) && __DEPRECATED #if defined(__DEPRECATED) && __DEPRECATED
#if defined(_LIBCPP_WARNING) #if defined(_LIBCPP_WARNING)
_LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set>") _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set>")
#else #else
# warning Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set> # warning Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set>
#endif #endif
#endif #endif
▲ Show 20 Lines • Show All 456 Lines • Show Last 20 Lines

libcxx/include/forward_list

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
#include <__iterator/move_iterator.h> #include <__iterator/move_iterator.h>
#include <__iterator/next.h> #include <__iterator/next.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 1,603 Lines • Show Last 20 Lines

libcxx/include/functional

Show First 20 Lines • Show All 523 Lines • ▼ Show 20 Lines
#include <concepts> #include <concepts>
#include <exception> #include <exception>
#include <memory> #include <memory>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <typeinfo> #include <typeinfo>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <utility>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_FUNCTIONAL #endif // _LIBCPP_FUNCTIONAL

libcxx/include/future

Show First 20 Lines • Show All 372 Lines • ▼ Show 20 Lines
#include <__utility/move.h> #include <__utility/move.h>
#include <exception> #include <exception>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <system_error> #include <system_error>
#include <thread> #include <thread>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <chrono>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#ifdef _LIBCPP_HAS_NO_THREADS #ifdef _LIBCPP_HAS_NO_THREADS
# error "<future> is not supported since libc++ has been configured without support for threads." # error "<future> is not supported since libc++ has been configured without support for threads."
#endif #endif
▲ Show 20 Lines • Show All 2,047 Lines • Show Last 20 Lines

libcxx/include/iterator

Show First 20 Lines • Show All 718 Lines • ▼ Show 20 Lines
#include <__memory/pointer_traits.h> #include <__memory/pointer_traits.h>
#include <compare> #include <compare>
#include <concepts> // Mandated by the Standard. #include <concepts> // Mandated by the Standard.
#include <cstddef> #include <cstddef>
#include <initializer_list> #include <initializer_list>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <exception>
# include <new>
# include <typeinfo>
# include <utility>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_ITERATOR #endif // _LIBCPP_ITERATOR

libcxx/include/list

Show First 20 Lines • Show All 196 Lines • ▼ Show 20 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 2,148 Lines • Show Last 20 Lines

libcxx/include/locale

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Lines
#include <cstdlib> #include <cstdlib>
#include <ctime> #include <ctime>
#include <ios> #include <ios>
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <streambuf> #include <streambuf>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
#endif
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
// Most unix variants have catopen. These are the specific ones that don't. // Most unix variants have catopen. These are the specific ones that don't.
# if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__) # if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)
# define _LIBCPP_HAS_CATOPEN 1 # define _LIBCPP_HAS_CATOPEN 1
# include <nl_types.h> # include <nl_types.h>
# endif # endif
#endif #endif
▲ Show 20 Lines • Show All 4,130 Lines • Show Last 20 Lines

libcxx/include/map

Show First 20 Lines • Show All 540 Lines • ▼ Show 20 Lines
#include <__node_handle> #include <__node_handle>
#include <__tree> #include <__tree>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <functional>
# include <iterator>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 1,778 Lines • Show Last 20 Lines

libcxx/include/memory

Show First 20 Lines • Show All 865 Lines • ▼ Show 20 Lines
#include <iosfwd> #include <iosfwd>
#include <new> #include <new>
#include <stdexcept> #include <stdexcept>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <typeinfo> #include <typeinfo>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

libcxx/include/mutex

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <cstdint> #include <cstdint>
#include <memory> #include <memory>
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
# include <tuple> # include <tuple>
#endif #endif
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <functional>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 497 Lines • Show Last 20 Lines

libcxx/include/numeric

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

libcxx/include/optional

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <initializer_list> #include <initializer_list>
#include <new> #include <new>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <atomic>
# include <chrono>
# include <climits>
# include <concepts>
# include <ctime>
# include <iterator>
# include <ratio>
# include <tuple>
# include <typeinfo>
# include <utility>
# include <variant>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
namespace std // purposefully not using versioning namespace namespace std // purposefully not using versioning namespace
▲ Show 20 Lines • Show All 1,388 Lines • Show Last 20 Lines

libcxx/include/ostream

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <bitset> #include <bitset>
#include <ios> #include <ios>
#include <locale> #include <locale>
#include <streambuf> #include <streambuf>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_ostream class _LIBCPP_TEMPLATE_VIS basic_ostream
▲ Show 20 Lines • Show All 952 Lines • Show Last 20 Lines

libcxx/include/queue

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Lines
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__memory/uses_allocator.h> #include <__memory/uses_allocator.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <deque> #include <deque>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <functional>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#include <initializer_list> #include <initializer_list>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 718 Lines • Show Last 20 Lines

libcxx/include/random

Show First 20 Lines • Show All 1,712 Lines • ▼ Show 20 Lines
#include <__random/student_t_distribution.h> #include <__random/student_t_distribution.h>
#include <__random/subtract_with_carry_engine.h> #include <__random/subtract_with_carry_engine.h>
#include <__random/uniform_int_distribution.h> #include <__random/uniform_int_distribution.h>
#include <__random/uniform_random_bit_generator.h> #include <__random/uniform_random_bit_generator.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <__random/weibull_distribution.h> #include <__random/weibull_distribution.h>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
#endif
// standard-mandated includes // standard-mandated includes
#include <initializer_list> #include <initializer_list>
#include <cmath> // for backward compatibility; TODO remove it #include <cmath> // for backward compatibility; TODO remove it
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Note that I have a follow-up patch ready to go that consolidates all those into the _LIBCPP_REMOVE_TRANSITIVE_INCLUDES block (in all headers).

ldionne: Note that I have a follow-up patch ready to go that consolidates all those into the…
#include <cstddef> // for backward compatibility; TODO remove it #include <cstddef> // for backward compatibility; TODO remove it
#include <cstdint> // for backward compatibility; TODO remove it #include <cstdint> // for backward compatibility; TODO remove it
#include <iosfwd> // for backward compatibility; TODO remove it #include <iosfwd> // for backward compatibility; TODO remove it
#include <limits> // for backward compatibility; TODO remove it #include <limits> // for backward compatibility; TODO remove it
#include <numeric> // for backward compatibility; TODO remove it #include <numeric> // for backward compatibility; TODO remove it
#include <string> // for backward compatibility; TODO remove it #include <string> // for backward compatibility; TODO remove it
#include <type_traits> // for backward compatibility; TODO remove it #include <type_traits> // for backward compatibility; TODO remove it
#include <vector> // for backward compatibility; TODO remove it #include <vector> // for backward compatibility; TODO remove it
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_RANDOM #endif // _LIBCPP_RANDOM

libcxx/include/regex

Show First 20 Lines • Show All 772 Lines • ▼ Show 20 Lines
#include <__utility/swap.h> #include <__utility/swap.h>
#include <deque> #include <deque>
#include <memory> #include <memory>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <vector> #include <vector>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 6,059 Lines • Show Last 20 Lines

libcxx/include/set

Show First 20 Lines • Show All 479 Lines • ▼ Show 20 Lines
#include <__iterator/erase_if_container.h> #include <__iterator/erase_if_container.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__iterator/reverse_iterator.h> #include <__iterator/reverse_iterator.h>
#include <__node_handle> #include <__node_handle>
#include <__tree> #include <__tree>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <functional>
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 1,081 Lines • Show Last 20 Lines

libcxx/include/span

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
#include <__ranges/size.h> #include <__ranges/size.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <array> // for array #include <array> // for array
#include <cstddef> // for byte #include <cstddef> // for byte
#include <limits> #include <limits>
#include <type_traits> // for remove_cv, etc #include <type_traits> // for remove_cv, etc
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 485 Lines • Show Last 20 Lines

libcxx/include/string

Show First 20 Lines • Show All 549 Lines • ▼ Show 20 Lines
#include <string_view> #include <string_view>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include <cwchar> # include <cwchar>
#endif #endif
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <iterator>
# include <new>
# include <typeinfo>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 4,140 Lines • Show Last 20 Lines

libcxx/include/string_view

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
#include <__ranges/size.h> #include <__ranges/size.h>
#include <__string/char_traits.h> #include <__string/char_traits.h>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 742 Lines • Show Last 20 Lines

libcxx/include/thread

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
#include <cstddef> #include <cstddef>
#include <iosfwd> #include <iosfwd>
#include <memory> #include <memory>
#include <system_error> #include <system_error>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <chrono>
# include <functional>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

libcxx/include/tuple

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.h>
#include <__utility/piecewise_construct.h> #include <__utility/piecewise_construct.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <cstddef> #include <cstddef>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <exception>
# include <iosfwd>
# include <new>
# include <typeinfo>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
▲ Show 20 Lines • Show All 1,600 Lines • Show Last 20 Lines

libcxx/include/typeindex

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__functional/unary_function.h> #include <__functional/unary_function.h>
#include <typeinfo> #include <typeinfo>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iosfwd>
# include <new>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

libcxx/include/unordered_map

Show First 20 Lines • Show All 525 Lines • ▼ Show 20 Lines
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <__node_handle> #include <__node_handle>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <stdexcept> #include <stdexcept>
#include <tuple> #include <tuple>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 2,083 Lines • Show Last 20 Lines

libcxx/include/unordered_set

Show First 20 Lines • Show All 468 Lines • ▼ Show 20 Lines
#include <__iterator/distance.h> #include <__iterator/distance.h>
#include <__iterator/erase_if_container.h> #include <__iterator/erase_if_container.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <__node_handle> #include <__node_handle>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <functional>
# include <iterator>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 1,315 Lines • Show Last 20 Lines

libcxx/include/utility

Show First 20 Lines • Show All 237 Lines • ▼ Show 20 Lines
#include <__utility/rel_ops.h> #include <__utility/rel_ops.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <__utility/to_underlying.h> #include <__utility/to_underlying.h>
#include <__utility/transaction.h> #include <__utility/transaction.h>
#include <__utility/unreachable.h> #include <__utility/unreachable.h>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <iosfwd>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#include <initializer_list> #include <initializer_list>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_UTILITY #endif // _LIBCPP_UTILITY

libcxx/include/valarray

Show First 20 Lines • Show All 354 Lines • ▼ Show 20 Lines
#include <__memory/uninitialized_algorithms.h> #include <__memory/uninitialized_algorithms.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <cmath> #include <cmath>
#include <cstddef> #include <cstddef>
#include <new> #include <new>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <functional>
#endif
// standard-mandated includes // standard-mandated includes
#include <initializer_list> #include <initializer_list>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 4,560 Lines • Show Last 20 Lines

libcxx/include/variant

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines
#include <exception> #include <exception>
#include <initializer_list> #include <initializer_list>
#include <limits> #include <limits>
#include <new> #include <new>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <typeinfo>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 1,556 Lines • Show Last 20 Lines

libcxx/include/vector

Show First 20 Lines • Show All 299 Lines • ▼ Show 20 Lines
#include <cstring> #include <cstring>
#include <iosfwd> // for forward declaration of vector #include <iosfwd> // for forward declaration of vector
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
# include <algorithm>
# include <typeinfo>
# include <utility>
#endif
// standard-mandated includes // standard-mandated includes
// [iterator.range] // [iterator.range]
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/data.h> #include <__iterator/data.h>
#include <__iterator/empty.h> #include <__iterator/empty.h>
#include <__iterator/reverse_access.h> #include <__iterator/reverse_access.h>
#include <__iterator/size.h> #include <__iterator/size.h>
▲ Show 20 Lines • Show All 2,922 Lines • Show Last 20 Lines

libcxx/test/libcxx/transitive_includes.sh.cpp

Show All 28 Lines
// UNSUPPORTED: modules-build // UNSUPPORTED: modules-build
// This test uses --trace-includes, which is not supported by GCC. // This test uses --trace-includes, which is not supported by GCC.
// UNSUPPORTED: gcc // UNSUPPORTED: gcc
// This test doesn't work on AIX or Windows, but it should. Needs investigation. // This test doesn't work on AIX or Windows, but it should. Needs investigation.
// XFAIL: buildhost=aix, buildhost=windows // XFAIL: buildhost=aix, buildhost=windows
// This test is not supported when we remove the transitive includes provided for backwards
// compatibility. When we bulk-remove them, we'll adjust the includes that are expected by
// this test instead.
// XFAIL: transitive-includes-disabled
// Prevent <ext/hash_map> from generating deprecated warnings for this test. // Prevent <ext/hash_map> from generating deprecated warnings for this test.
#if defined(__DEPRECATED) #if defined(__DEPRECATED)
# undef __DEPRECATED # undef __DEPRECATED
#endif #endif
/* /*
BEGIN-SCRIPT BEGIN-SCRIPT
▲ Show 20 Lines • Show All 630 Lines • Show Last 20 Lines

libcxx/test/libcxx/transitive_includes/expected.algorithm

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

libcxx/test/libcxx/transitive_includes/expected.any

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

libcxx/test/libcxx/transitive_includes/expected.array

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

libcxx/test/libcxx/transitive_includes/expected.atomic

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

libcxx/test/libcxx/transitive_includes/expected.barrier

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

libcxx/test/libcxx/transitive_includes/expected.bit

bit bit
cstddef cstddef
cstdint cstdint
cstdlib cstdlib
iosfwd
limits limits
type_traits type_traits
version version

libcxx/test/libcxx/transitive_includes/expected.bitset

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

libcxx/test/libcxx/transitive_includes/expected.ccomplex

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

libcxx/test/libcxx/transitive_includes/expected.charconv

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

libcxx/test/libcxx/transitive_includes/expected.codecvt

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

libcxx/test/libcxx/transitive_includes/expected.complex

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

libcxx/test/libcxx/transitive_includes/expected.condition_variable

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

libcxx/test/libcxx/transitive_includes/expected.coroutine

cmath cmath
compare compare
coroutine coroutine
cstddef cstddef
cstdint cstdint
cstring cstring
iosfwd
limits limits
type_traits type_traits
version version

libcxx/test/libcxx/transitive_includes/expected.ctgmath

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

libcxx/test/libcxx/transitive_includes/expected.deque

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

libcxx/test/libcxx/transitive_includes/expected.experimental_algorithm

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

libcxx/test/libcxx/transitive_includes/expected.experimental_coroutine

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

libcxx/test/libcxx/transitive_includes/expected.experimental_deque

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

libcxx/test/libcxx/transitive_includes/expected.experimental_forward_list

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

libcxx/test/libcxx/transitive_includes/expected.experimental_functional

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

libcxx/test/libcxx/transitive_includes/expected.experimental_iterator

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

libcxx/test/libcxx/transitive_includes/expected.experimental_list

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

libcxx/test/libcxx/transitive_includes/expected.experimental_map

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

libcxx/test/libcxx/transitive_includes/expected.experimental_memory_resource

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

libcxx/test/libcxx/transitive_includes/expected.experimental_propagate_const

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

libcxx/test/libcxx/transitive_includes/expected.experimental_regex

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

libcxx/test/libcxx/transitive_includes/expected.experimental_set

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

libcxx/test/libcxx/transitive_includes/expected.experimental_simd

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

libcxx/test/libcxx/transitive_includes/expected.experimental_string

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

libcxx/test/libcxx/transitive_includes/expected.experimental_unordered_map

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

libcxx/test/libcxx/transitive_includes/expected.experimental_unordered_set

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

libcxx/test/libcxx/transitive_includes/expected.experimental_utility

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

libcxx/test/libcxx/transitive_includes/expected.experimental_vector

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

libcxx/test/libcxx/transitive_includes/expected.ext_hash_map

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

libcxx/test/libcxx/transitive_includes/expected.ext_hash_set

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

libcxx/test/libcxx/transitive_includes/expected.filesystem

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

libcxx/test/libcxx/transitive_includes/expected.format

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

libcxx/test/libcxx/transitive_includes/expected.forward_list

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

libcxx/test/libcxx/transitive_includes/expected.fstream

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

libcxx/test/libcxx/transitive_includes/expected.functional

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

libcxx/test/libcxx/transitive_includes/expected.future

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

libcxx/test/libcxx/transitive_includes/expected.iomanip

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

libcxx/test/libcxx/transitive_includes/expected.ios

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

libcxx/test/libcxx/transitive_includes/expected.iostream

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

libcxx/test/libcxx/transitive_includes/expected.istream

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

libcxx/test/libcxx/transitive_includes/expected.iterator

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

libcxx/test/libcxx/transitive_includes/expected.latch

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

libcxx/test/libcxx/transitive_includes/expected.list

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

libcxx/test/libcxx/transitive_includes/expected.locale

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

libcxx/test/libcxx/transitive_includes/expected.map

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

libcxx/test/libcxx/transitive_includes/expected.memory

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

libcxx/test/libcxx/transitive_includes/expected.mutex

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

libcxx/test/libcxx/transitive_includes/expected.numeric

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

libcxx/test/libcxx/transitive_includes/expected.optional

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

libcxx/test/libcxx/transitive_includes/expected.ostream

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

libcxx/test/libcxx/transitive_includes/expected.queue

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

libcxx/test/libcxx/transitive_includes/expected.random

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

libcxx/test/libcxx/transitive_includes/expected.ranges

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

libcxx/test/libcxx/transitive_includes/expected.regex

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

libcxx/test/libcxx/transitive_includes/expected.scoped_allocator

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

libcxx/test/libcxx/transitive_includes/expected.semaphore

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

libcxx/test/libcxx/transitive_includes/expected.set

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

libcxx/test/libcxx/transitive_includes/expected.shared_mutex

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

libcxx/test/libcxx/transitive_includes/expected.span

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

libcxx/test/libcxx/transitive_includes/expected.sstream

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

libcxx/test/libcxx/transitive_includes/expected.stack

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

libcxx/test/libcxx/transitive_includes/expected.streambuf

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

libcxx/test/libcxx/transitive_includes/expected.string

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

libcxx/test/libcxx/transitive_includes/expected.string_view

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

libcxx/test/libcxx/transitive_includes/expected.strstream

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

libcxx/test/libcxx/transitive_includes/expected.system_error

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

libcxx/test/libcxx/transitive_includes/expected.thread

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

libcxx/test/libcxx/transitive_includes/expected.tuple

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

libcxx/test/libcxx/transitive_includes/expected.typeindex

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

libcxx/test/libcxx/transitive_includes/expected.unordered_map

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

libcxx/test/libcxx/transitive_includes/expected.unordered_set

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

libcxx/test/libcxx/transitive_includes/expected.utility

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

libcxx/test/libcxx/transitive_includes/expected.valarray

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

libcxx/test/libcxx/transitive_includes/expected.variant

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

libcxx/test/libcxx/transitive_includes/expected.vector

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

libcxx/utils/ci/buildkite-pipeline.yml

Show First 20 Lines • Show All 330 Lines • ▼ Show 20 Lines - label: "Legacy LLVM_ENABLE_PROJECTS build"
os: "linux" os: "linux"
retry: retry:
automatic: automatic:
- exit_status: -1 # Agent was lost - exit_status: -1 # Agent was lost
limit: 2 limit: 2
timeout_in_minutes: 120 timeout_in_minutes: 120
# Tests with various build configurations. # Tests with various build configurations.
- label: "Static libraries" - label: "Static libraries"
command: "libcxx/utils/ci/run-buildbot generic-static" command: "libcxx/utils/ci/run-buildbot generic-static"
artifact_paths: artifact_paths:
- "**/test-results.xml" - "**/test-results.xml"
- "**/*.abilist" - "**/*.abilist"
agents: agents:
queue: "libcxx-builders" queue: "libcxx-builders"
os: "linux" os: "linux"
Show All 40 Lines agents:
queue: "libcxx-builders" queue: "libcxx-builders"
os: "linux" os: "linux"
retry: retry:
automatic: automatic:
- exit_status: -1 # Agent was lost - exit_status: -1 # Agent was lost
limit: 2 limit: 2
timeout_in_minutes: 120 timeout_in_minutes: 120
- label: "No transitive includes"
command: "libcxx/utils/ci/run-buildbot generic-no-transitive-includes"
artifact_paths:
- "**/test-results.xml"
- "**/*.abilist"
agents:
queue: "libcxx-builders"
os: "linux"
retry:
automatic:
- exit_status: -1 # Agent was lost
limit: 2
timeout_in_minutes: 120
- label: "With LLVM's libunwind" - label: "With LLVM's libunwind"
command: "libcxx/utils/ci/run-buildbot generic-with_llvm_unwinder" command: "libcxx/utils/ci/run-buildbot generic-with_llvm_unwinder"
artifact_paths: artifact_paths:
- "**/test-results.xml" - "**/test-results.xml"
- "**/*.abilist" - "**/*.abilist"
agents: agents:
queue: "libcxx-builders" queue: "libcxx-builders"
os: "linux" os: "linux"
▲ Show 20 Lines • Show All 430 Lines • Show Last 20 Lines

libcxx/utils/ci/run-buildbot

Show First 20 Lines • Show All 318 Lines • ▼ Show 20 Linesgeneric-ubsan)
generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-ubsan.cmake" generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-ubsan.cmake"
check-runtimes check-runtimes
;; ;;
generic-with_llvm_unwinder) generic-with_llvm_unwinder)
clean clean
generate-cmake -DLIBCXXABI_USE_LLVM_UNWINDER=ON generate-cmake -DLIBCXXABI_USE_LLVM_UNWINDER=ON
check-runtimes check-runtimes
;; ;;
generic-no-transitive-includes)
clean
generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-transitive-includes.cmake"
check-runtimes
;;
generic-no-threads) generic-no-threads)
clean clean
generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-threads.cmake" generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-threads.cmake"
check-runtimes check-runtimes
;; ;;
generic-no-filesystem) generic-no-filesystem)
clean clean
generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-filesystem.cmake" generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-filesystem.cmake"
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

libcxx/utils/libcxx/test/params.py

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Lines Parameter(name='enable_assertions', choices=[True, False], type=bool, default=False,
AddFeature('libcpp-has-assertions') AddFeature('libcpp-has-assertions')
] if assertions else []), ] if assertions else []),
Parameter(name='additional_features', type=list, default=[], Parameter(name='additional_features', type=list, default=[],
help="A comma-delimited list of additional features that will be enabled when running the tests. " help="A comma-delimited list of additional features that will be enabled when running the tests. "
"This should be used sparingly since specifying ad-hoc features manually is error-prone and " "This should be used sparingly since specifying ad-hoc features manually is error-prone and "
"brittle in the long run as changes are made to the test suite.", "brittle in the long run as changes are made to the test suite.",
actions=lambda features: [AddFeature(f) for f in features]), actions=lambda features: [AddFeature(f) for f in features]),
Parameter(name='enable_transitive_includes', choices=[True, False], type=bool, default=True,
help="Whether to enable backwards-compatibility transitive includes when running the tests. This "
"is provided to ensure that the trimmed-down version of libc++ does not bit-rot in between "
"points at which we bulk-remove transitive includes.",
actions=lambda enabled: [] if enabled else [
AddFeature('transitive-includes-disabled'),
AddCompileFlag('-D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES')
]),
] ]
DEFAULT_PARAMETERS += [ DEFAULT_PARAMETERS += [
Parameter(name='use_system_cxx_lib', choices=[True, False], type=bool, default=False, Parameter(name='use_system_cxx_lib', choices=[True, False], type=bool, default=False,
help=""" help="""
Whether the test suite is being *run* against the library shipped on the Whether the test suite is being *run* against the library shipped on the
target triple in use, as opposed to the trunk library. target triple in use, as opposed to the trunk library.
Show All 28 Lines