[libc++] Split __allocator_destructor out of shared_ptr.h

[ldionne]

Please wait for CI to be back and green before merging, though.

[philnik]

poke CI

[philnik]

• Generate files

[philnik]

• Try to fix CI

[philnik]

• Try to fix CI

[philnik]

• Try to fix CI

[philnik]

• Try to fix CI

[philnik]

• Next try

[huixie90]

LGTM

libcxx/include/__memory/allocator_destructor.h

37

nit: can this member function be const?

[philnik]

• Rebased
• Try to fix CI

libcxx/include/__memory/allocator_destructor.h

37

Maybe, but I wouldn't change it here, since I'm just moving the code.

[philnik]

• Next try

[philnik]

Rebased

[philnik]

Add shared_ptr.h include to <ostream>

[philnik]

Generate transitive include lists

libcxx/include/CMakeLists.txt

set(files
   __locale
   __mbstate_t.h
   __memory/addressof.h
   __memory/align.h
   __memory/allocate_at_least.h
   __memory/allocation_guard.h
   __memory/allocator.h
   __memory/allocator_arg_t.h
+  __memory/allocator_destructor.h
   __memory/allocator_traits.h
   __memory/assume_aligned.h
   __memory/auto_ptr.h
   __memory/builtin_new_allocator.h
   __memory/compressed_pair.h
   __memory/concepts.h
   __memory/construct_at.h
   __memory/destruct_n.h

libcxx/include/__functional/function.h

 #include <__assert>
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
+#include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/builtin_new_allocator.h>
 #include <__memory/compressed_pair.h>
-#include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <exception>
 #include <new>
 #include <tuple>

libcxx/include/__locale

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___LOCALE
 #define _LIBCPP___LOCALE
 
 #include <__availability>
 #include <__config>
-#include <__memory/shared_ptr.h>
 #include <cctype>
 #include <cstdint>
 #include <locale.h>
 #include <mutex>
 #include <string>
 
+// Some platforms require more includes than others. Keep the includes on all plaforms for now.
+#include <cstddef>
+#include <cstring>
+
 #if defined(_LIBCPP_MSVCRT_LIKE)
 # include <__support/win32/locale_win32.h>
-# include <cstring>
 #elif defined(_AIX) || defined(__MVS__)
 # include <__support/ibm/xlocale.h>
 #elif defined(__ANDROID__)
 # include <__support/android/locale_bionic.h>
 #elif defined(__sun__)
 # include <__support/solaris/xlocale.h>
 # include <xlocale.h>
 #elif defined(_NEWLIB_VERSION)

libcxx/include/__memory/allocator_destructor.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_ALLOCATOR_DESTRUCTOR_H
+#define _LIBCPP___MEMORY_ALLOCATOR_DESTRUCTOR_H
+
+#include <__config>
+#include <__memory/allocator_traits.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Alloc>
+class __allocator_destructor
+{
+    typedef _LIBCPP_NODEBUG allocator_traits<_Alloc> __alloc_traits;
+public:
+    typedef _LIBCPP_NODEBUG typename __alloc_traits::pointer pointer;
+    typedef _LIBCPP_NODEBUG typename __alloc_traits::size_type size_type;
+private:
+    _Alloc& __alloc_;
+    size_type __s_;
+public:
+    _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s)
+             _NOEXCEPT
+        : __alloc_(__a), __s_(__s) {}
+    _LIBCPP_INLINE_VISIBILITY
+    void operator()(pointer __p) _NOEXCEPT
+        {__alloc_traits::deallocate(__alloc_, __p, __s_);}
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_ALLOCATOR_DESTRUCTOR_H

libcxx/include/__memory/shared_ptr.h

 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__iterator/access.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
+#include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/auto_ptr.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
 
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Alloc>
-class __allocator_destructor
-{
-    typedef _LIBCPP_NODEBUG allocator_traits<_Alloc> __alloc_traits;
-public:
-    typedef _LIBCPP_NODEBUG typename __alloc_traits::pointer pointer;
-    typedef _LIBCPP_NODEBUG typename __alloc_traits::size_type size_type;
-private:
-    _Alloc& __alloc_;
-    size_type __s_;
-public:
-    _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s)
-             _NOEXCEPT
-        : __alloc_(__a), __s_(__s) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-        {__alloc_traits::deallocate(__alloc_, __p, __s_);}
-};
-
 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
 // should be sufficient for thread safety.
 // See https://llvm.org/PR22803
 #if defined(__clang__) && __has_builtin(__atomic_add_fetch)          \
                        && defined(__ATOMIC_RELAXED)                  \
                        && defined(__ATOMIC_ACQ_REL)
 #   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
 #elif defined(_LIBCPP_COMPILER_GCC)

libcxx/include/__split_buffer

 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
-#include <__memory/shared_ptr.h>
 #include <__memory/swap_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/any

 } // namespace std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__memory/allocator.h>
+#include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
-#include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstdlib>
 #include <initializer_list>
 #include <type_traits>

 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
+#  include <iosfwd>
 #  include <iterator>
 #  include <memory>
 #  include <variant>
 #endif
 
 #endif // _LIBCPP_ANY

libcxx/include/codecvt

public:
     _LIBCPP_INLINE_VISIBILITY
     ~codecvt_utf8_utf16() {}
 };
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
+#  include <cstddef>
+#  include <cstdlib>
+#  include <cstring>
+#  include <initializer_list>
+#  include <iosfwd>
+#  include <limits>
+#  include <new>
+#  include <stdexcept>
+#  include <type_traits>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_CODECVT

libcxx/include/deque

 #include <__algorithm/unwrap_iter.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__format/enable_insertable.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
+#include <__memory/allocator_destructor.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/temp_value.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
+#  include <atomic>
 #  include <concepts>
 #  include <functional>
+#  include <iosfwd>
 #  include <iterator>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_DEQUE

libcxx/include/forward_list

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
+#include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
-#include <__memory/shared_ptr.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <limits>
 #include <type_traits>

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
+#  include <atomic>
 #  include <concepts>
 #  include <functional>
+#  include <iosfwd>
 #  include <iterator>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_FORWARD_LIST

libcxx/include/fstream

 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
+#  include <iosfwd>
+#  include <limits>
+#  include <new>
+#  include <stdexcept>
 #endif
 
 #endif // _LIBCPP_FSTREAM

libcxx/include/future

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__memory/allocator_arg_t.h>
+#include <__memory/allocator_destructor.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <exception>
 #include <mutex>
 #include <new>
 #include <system_error>

libcxx/include/ios

defaultfloat(ios_base& __str)
     __str.unsetf(ios_base::floatfield);
     return __str;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <cstddef>
+#  include <cstdlib>
+#  include <cstring>
+#  include <initializer_list>
+#  include <limits>
+#  include <new>
+#  include <stdexcept>
+#  include <type_traits>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_IOS

libcxx/include/list

 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
+#include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
-#include <__memory/shared_ptr.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstring>

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
+#  include <atomic>
 #  include <concepts>
 #  include <functional>
+#  include <iosfwd>
 #  include <iterator>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_LIST

libcxx/include/locale

 
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
 #  include <cstdarg>
 #  include <iterator>
+#  include <stdexcept>
+#  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_LOCALE

libcxx/include/module.modulemap.in

module memory {
 
     module __memory {
       module addressof                       { private header "__memory/addressof.h" }
       module align                           { private header "__memory/align.h" }
       module allocate_at_least               { private header "__memory/allocate_at_least.h" }
       module allocation_guard                { private header "__memory/allocation_guard.h" }
       module allocator                       { private header "__memory/allocator.h" }
       module allocator_arg_t                 { private header "__memory/allocator_arg_t.h" }
+      module allocator_destructor            { private header "__memory/allocator_destructor.h" }
       module allocator_traits                { private header "__memory/allocator_traits.h" }
       module assume_aligned                  { private header "__memory/assume_aligned.h" }
       module auto_ptr                        { private header "__memory/auto_ptr.h" }
       module builtin_new_allocator           { private header "__memory/builtin_new_allocator.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
       module concepts                        { private header "__memory/concepts.h" }
       module construct_at                    { private header "__memory/construct_at.h" }
       module destruct_n                      { private header "__memory/destruct_n.h" }

libcxx/include/ostream

 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <bitset>
 #include <ios>
 #include <locale>
 #include <new>
 #include <streambuf>
 #include <version>
 

 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <concepts>
 #  include <iterator>
 #endif
 
 #endif // _LIBCPP_OSTREAM

libcxx/include/regex

 #include <__config>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
+#include <cstring>
 #include <deque>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include <version>
 
 // standard-mandated includes
 

 #endif
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <atomic>
 #  include <concepts>
+#  include <iosfwd>
 #  include <iterator>
+#  include <new>
+#  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_REGEX

libcxx/include/vector

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
+#  include <atomic>
 #  include <concepts>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_VECTOR

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__locale> // expected-error@*:* {{use of private header from outside its module: '__locale'}}
 #include <__mbstate_t.h> // expected-error@*:* {{use of private header from outside its module: '__mbstate_t.h'}}
 #include <__memory/addressof.h> // expected-error@*:* {{use of private header from outside its module: '__memory/addressof.h'}}
 #include <__memory/align.h> // expected-error@*:* {{use of private header from outside its module: '__memory/align.h'}}
 #include <__memory/allocate_at_least.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocate_at_least.h'}}
 #include <__memory/allocation_guard.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocation_guard.h'}}
 #include <__memory/allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator.h'}}
 #include <__memory/allocator_arg_t.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_arg_t.h'}}
+#include <__memory/allocator_destructor.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_destructor.h'}}
 #include <__memory/allocator_traits.h> // expected-error@*:* {{use of private header from outside its module: '__memory/allocator_traits.h'}}
 #include <__memory/assume_aligned.h> // expected-error@*:* {{use of private header from outside its module: '__memory/assume_aligned.h'}}
 #include <__memory/auto_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__memory/auto_ptr.h'}}
 #include <__memory/builtin_new_allocator.h> // expected-error@*:* {{use of private header from outside its module: '__memory/builtin_new_allocator.h'}}
 #include <__memory/compressed_pair.h> // expected-error@*:* {{use of private header from outside its module: '__memory/compressed_pair.h'}}
 #include <__memory/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__memory/concepts.h'}}
 #include <__memory/construct_at.h> // expected-error@*:* {{use of private header from outside its module: '__memory/construct_at.h'}}
 #include <__memory/destruct_n.h> // expected-error@*:* {{use of private header from outside its module: '__memory/destruct_n.h'}}

libcxx/test/libcxx/transitive_includes/cxx03.csv

 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
 charconv type_traits
 chrono compare
+chrono concepts
 chrono cstdint
 chrono ctime
 chrono limits
 chrono ratio
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath type_traits

 optional ratio
 optional stdexcept
 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
+ostream atomic
 ostream bitset
+ostream concepts
 ostream cstddef
 ostream cstdint
+ostream cstdlib
 ostream cstring
+ostream initializer_list
 ostream ios
+ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
+ostream stdexcept
 ostream streambuf
 ostream type_traits
+ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx11.csv

 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
 charconv type_traits
 chrono compare
+chrono concepts
 chrono cstdint
 chrono ctime
 chrono limits
 chrono ratio
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath type_traits

 optional ratio
 optional stdexcept
 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
+ostream atomic
 ostream bitset
+ostream concepts
 ostream cstddef
 ostream cstdint
+ostream cstdlib
 ostream cstring
+ostream initializer_list
 ostream ios
+ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
+ostream stdexcept
 ostream streambuf
 ostream type_traits
+ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx14.csv

 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
 charconv type_traits
 chrono compare
+chrono concepts
 chrono cstdint
 chrono ctime
 chrono limits
 chrono ratio
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath type_traits

 optional ratio
 optional stdexcept
 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
+ostream atomic
 ostream bitset
+ostream concepts
 ostream cstddef
 ostream cstdint
+ostream cstdlib
 ostream cstring
+ostream initializer_list
 ostream ios
+ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
+ostream stdexcept
 ostream streambuf
 ostream type_traits
+ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx17.csv

 charconv cstdint
 charconv cstdlib
 charconv cstring
 charconv initializer_list
 charconv iosfwd
 charconv limits
 charconv type_traits
 chrono compare
+chrono concepts
 chrono cstdint
 chrono ctime
 chrono limits
 chrono ratio
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath type_traits

 optional ratio
 optional stdexcept
 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
+ostream atomic
 ostream bitset
+ostream concepts
 ostream cstddef
 ostream cstdint
+ostream cstdlib
 ostream cstring
+ostream initializer_list
 ostream ios
+ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
+ostream stdexcept
 ostream streambuf
 ostream type_traits
+ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx20.csv

 optional ratio
 optional stdexcept
 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
+ostream atomic
 ostream bitset
+ostream concepts
 ostream cstddef
 ostream cstdint
+ostream cstdlib
 ostream cstring
+ostream initializer_list
 ostream ios
+ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
+ostream stdexcept
 ostream streambuf
 ostream type_traits
+ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque
 queue functional
 queue initializer_list

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 algorithm bit
 algorithm climits
 algorithm cstddef
 algorithm cstdint
 algorithm cstdlib
 algorithm cstring
 algorithm initializer_list
 algorithm iosfwd
 algorithm limits
 algorithm new
 algorithm type_traits
 algorithm version
-any atomic
 any cstddef
 any cstdint
 any cstdlib
 any cstring
 any initializer_list
-any iosfwd
 any limits
 any new
 any stdexcept
 any type_traits
 any typeinfo
 any version
 array compare
 array cstddef

 chrono stdexcept
 chrono string
 chrono string_view
 chrono type_traits
 chrono version
 cinttypes cstdint
 cmath type_traits
 cmath version
-codecvt atomic
 codecvt cctype
 codecvt cstddef
 codecvt cstdint
-codecvt cstdlib
 codecvt cstring
-codecvt initializer_list
-codecvt iosfwd
-codecvt limits
 codecvt mutex
-codecvt new
-codecvt stdexcept
 codecvt string
-codecvt type_traits
-codecvt typeinfo
 codecvt version
 compare cmath
 compare cstddef
 compare cstdint
 compare limits
 compare type_traits
 compare version
 complex cmath

 coroutine limits
 coroutine type_traits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
-deque atomic
 deque compare
 deque cstddef
 deque cstdint
 deque cstdlib
 deque cstring
 deque initializer_list
-deque iosfwd
 deque limits
 deque new
 deque stdexcept
 deque tuple
 deque type_traits
-deque typeinfo
 deque version
 exception cstddef
 exception cstdlib
 exception type_traits
 exception version
 execution version
 experimental/algorithm algorithm
 experimental/algorithm cstddef

 format limits
 format locale
 format optional
 format stdexcept
 format string
 format string_view
 format type_traits
 format version
-forward_list atomic
 forward_list compare
 forward_list cstddef
 forward_list cstdint
 forward_list cstdlib
 forward_list cstring
 forward_list initializer_list
-forward_list iosfwd
 forward_list limits
 forward_list new
 forward_list stdexcept
 forward_list tuple
 forward_list type_traits
-forward_list typeinfo
 forward_list version
-fstream atomic
 fstream cctype
 fstream cstddef
 fstream cstdint
 fstream cstdio
 fstream cstdlib
 fstream cstring
 fstream filesystem
 fstream initializer_list
-fstream iosfwd
 fstream istream
-fstream limits
 fstream mutex
-fstream new
 fstream ostream
-fstream stdexcept
 fstream string
 fstream type_traits
 fstream typeinfo
 fstream version
 functional array
 functional atomic
 functional cstddef
 functional cstdint

 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios atomic
 ios cctype
 ios cstddef
 ios cstdint
-ios cstdlib
 ios cstring
-ios initializer_list
 ios iosfwd
-ios limits
 ios mutex
-ios new
-ios stdexcept
 ios string
 ios system_error
-ios type_traits
-ios typeinfo
 ios version
 iosfwd version
 iostream ios
 iostream istream
 iostream ostream
 iostream streambuf
 iostream version
 istream cstddef

 iterator type_traits
 iterator variant
 iterator version
 latch atomic
 latch limits
 latch version
 limits type_traits
 limits version
-list atomic
 list compare
 list cstddef
 list cstdint
 list cstdlib
 list cstring
 list initializer_list
-list iosfwd
 list limits
 list new
 list stdexcept
 list tuple
 list type_traits
-list typeinfo
 list version
-locale atomic
 locale cctype
 locale cstddef
 locale cstdint
 locale cstdio
 locale cstdlib
 locale cstring
 locale ctime
 locale initializer_list
 locale ios
 locale iosfwd
 locale limits
 locale mutex
 locale new
-locale stdexcept
 locale streambuf
 locale string
 locale type_traits
-locale typeinfo
 locale version
 map compare
 map cstddef
 map cstdlib
 map initializer_list
 map limits
 map new
 map optional

 optional cstdint
 optional cstring
 optional initializer_list
 optional limits
 optional new
 optional stdexcept
 optional type_traits
 optional version
+ostream atomic
 ostream bitset
 ostream cstddef
 ostream cstdint
+ostream cstdlib
 ostream cstring
+ostream initializer_list
 ostream ios
+ostream iosfwd
 ostream limits
 ostream locale
 ostream new
+ostream stdexcept
 ostream streambuf
 ostream type_traits
+ostream typeinfo
 ostream version
 queue compare
 queue cstddef
 queue cstdlib
 queue deque
 queue initializer_list
 queue limits
 queue type_traits

 ranges tuple
 ranges type_traits
 ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio type_traits
 ratio version
-regex atomic
 regex cctype
 regex compare
 regex cstddef
 regex cstdint
 regex cstdlib
 regex cstring
 regex deque
 regex initializer_list
-regex iosfwd
 regex limits
 regex mutex
-regex new
 regex stdexcept
 regex string
 regex type_traits
-regex typeinfo
 regex vector
 regex version
 scoped_allocator cstddef
 scoped_allocator limits
 scoped_allocator new
 scoped_allocator tuple
 scoped_allocator type_traits
 scoped_allocator version

 variant cstring
 variant exception
 variant initializer_list
 variant limits
 variant new
 variant tuple
 variant type_traits
 variant version
-vector atomic
 vector climits
 vector compare
 vector cstddef
 vector cstdint
 vector cstdlib
 vector cstring
 vector initializer_list
 vector iosfwd
 vector limits
 vector new
 vector stdexcept
 vector tuple
 vector type_traits
-vector typeinfo
 vector version