[libc++] Granularize <type_traits> includes

[philnik]

Try to fix CI

[ldionne]

LGTM w/ green CI.

Pinging vendors just for heads up, since this one might break a few users. type_traits is very common and some folks may have started compiling with -std=c++2b already.

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[philnik]

Next try

[uabelho]

Is it only me that see problems like

******************** TEST 'llvm-libc++-shared.cfg.in :: libcxx/transitive_includes.sh.cpp' FAILED ********************

with this patch?

I get

$ ":" "RUN: at line 557"
note: command had no output on stdout or stderr
$ "diff" "-w" "/repo/uabelho/dev-main/libcxx/test/libcxx/transitive_includes/cxx2b.csv" "/repo/uabelho/dev-main/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/Output/transitive_includes.sh.cpp.dir/t.tmp/transitive_includes.csv"
# command output:
*** /repo/uabelho/dev-main/libcxx/test/libcxx/transitive_includes/cxx2b.csv
--- /repo/uabelho/dev-main/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/Output/transitive_includes.sh.cpp.dir/t.tmp/transitive_includes.csv
***************
*** 245,251 ****
  formatstring
  formatstring_view
  formattuple
- formattype_traits
  formatvector
  formatversion
  forward_listcompare
--- 245,250 ----

error: command failed with exit status: 1

[uabelho]

In D145320#4180718, @uabelho wrote:

Is it only me that see problems like

******************** TEST 'llvm-libc++-shared.cfg.in :: libcxx/transitive_includes.sh.cpp' FAILED ********************

with this patch?

I get

$ ":" "RUN: at line 557"
note: command had no output on stdout or stderr
$ "diff" "-w" "/repo/uabelho/dev-main/libcxx/test/libcxx/transitive_includes/cxx2b.csv" "/repo/uabelho/dev-main/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/Output/transitive_includes.sh.cpp.dir/t.tmp/transitive_includes.csv"
# command output:
*** /repo/uabelho/dev-main/libcxx/test/libcxx/transitive_includes/cxx2b.csv
--- /repo/uabelho/dev-main/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/test/libcxx/Output/transitive_includes.sh.cpp.dir/t.tmp/transitive_includes.csv
***************
*** 245,251 ****
  formatstring
  formatstring_view
  formattuple
- formattype_traits
  formatvector
  formatversion
  forward_listcompare
--- 245,250 ----

error: command failed with exit status: 1

Seems to be fixed in https://reviews.llvm.org/D145651

[krasimir]

I submitted https://github.com/llvm/llvm-project/commit/8227349f7e4f1a6ceb4cceb464c8f4420ff1dd0a to address errors we started seeing in <optional> after this. Leaving a comment here so the author can take a look and check if this is reasonable.

libcxx/include/__bit_reference

 #include <__algorithm/fill_n.h>
 #include <__algorithm/min.h>
 #include <__bit/countr.h>
 #include <__bit/popcount.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
-#include <type_traits>
+#include <__type_traits/conditional.h>
+#include <__utility/swap.h>
+#include <cstring>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__chrono/hh_mm_ss.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___CHRONO_HH_MM_SS_H
 #define _LIBCPP___CHRONO_HH_MM_SS_H
 
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
+#include <__type_traits/common_type.h>
 #include <ratio>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__filesystem/filesystem_error.h

 #include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <__memory/shared_ptr.h>
 #include <__utility/forward.h>
 #include <iosfwd>
 #include <new>
 #include <system_error>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM

libcxx/include/__filesystem/path.h

 #include <__algorithm/replace.h>
 #include <__algorithm/replace_copy.h>
 #include <__availability>
 #include <__config>
 #include <__functional/unary_function.h>
 #include <__fwd/hash.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/remove_const.h>
+#include <__type_traits/remove_pointer.h>
 #include <cstddef>
 #include <string>
 #include <string_view>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 # include <iomanip> // for quoted
 # include <locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__filesystem/u8path.h

 #ifndef _LIBCPP___FILESYSTEM_U8PATH_H
 #define _LIBCPP___FILESYSTEM_U8PATH_H
 
 #include <__algorithm/unwrap_iter.h>
 #include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <string>
-#include <type_traits>
 
 // Only required on Windows for __widen_from_utf8, and included conservatively
 // because it requires support for localization.
 #if defined(_LIBCPP_WIN32API)
 # include <locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__format/buffer.h

 #include <__format/concepts.h>
 #include <__format/enable_insertable.h>
 #include <__format/format_to_n_result.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
+#include <__type_traits/add_pointer.h>
 #include <__utility/move.h>
 #include <cstddef>
 #include <string_view>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__format/format_arg.h

 #include <__assert>
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
 #include <__functional/invoke.h>
 #include <__memory/addressof.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/unreachable.h>
 #include <__variant/monostate.h>
 #include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__format/format_arg_store.h

 #  pragma GCC system_header
 #endif
 
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_arg.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/extent.h>
+#include <__type_traits/is_same.h>
 #include <__utility/forward.h>
 #include <string>
 #include <string_view>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 

libcxx/include/__format/format_parse_context.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMAT_PARSE_CONTEXT_H
 #define _LIBCPP___FORMAT_FORMAT_PARSE_CONTEXT_H
 
 #include <__config>
 #include <__format/format_error.h>
+#include <__type_traits/is_constant_evaluated.h>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__format/formatter_floating_point.h

 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
 #include <__memory/allocator.h>
+#include <__type_traits/conditional.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <charconv>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #  include <locale>
 #endif
 

libcxx/include/__format/parser_std_format_spec.h

 #include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_error.h>
 #include <__format/format_parse_context.h>
 #include <__format/format_string.h>
 #include <__format/unicode.h>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h> // iter_value_t
+#include <__type_traits/common_type.h>
+#include <__type_traits/is_trivially_copyable.h>
 #include <__variant/monostate.h>
 #include <cstdint>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__functional/bind.h

 #ifndef _LIBCPP___FUNCTIONAL_BIND_H
 #define _LIBCPP___FUNCTIONAL_BIND_H
 
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/weak_result_type.h>
 #include <cstddef>
 #include <tuple>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Tp>

libcxx/include/__functional/bind_back.h

 #define _LIBCPP___FUNCTIONAL_BIND_BACK_H
 
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/perfect_forward.h>
 #include <__utility/forward.h>
 #include <__utility/integer_sequence.h>
 #include <tuple>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__functional/bind_front.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_BIND_FRONT_H
 #define _LIBCPP___FUNCTIONAL_BIND_FRONT_H
 
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/perfect_forward.h>
 #include <__utility/forward.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__functional/compose.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_COMPOSE_H
 #define _LIBCPP___FUNCTIONAL_COMPOSE_H
 
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/perfect_forward.h>
 #include <__utility/forward.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__functional/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/unique_ptr.h>
+#include <__type_traits/aligned_storage.h>
+#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_trivially_destructible.h>
 #include <__type_traits/strip_signature.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <exception>
 #include <new>
 #include <tuple>
-#include <type_traits>
 #include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 

libcxx/include/__functional/is_transparent.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_IS_TRANSPARENT
 #define _LIBCPP___FUNCTIONAL_IS_TRANSPARENT
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/void_t.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 14

libcxx/include/__functional/mem_fn.h

 #ifndef _LIBCPP___FUNCTIONAL_MEM_FN_H
 #define _LIBCPP___FUNCTIONAL_MEM_FN_H
 
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/weak_result_type.h>
 #include <__utility/forward.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>

libcxx/include/__functional/not_fn.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_NOT_FN_H
 #define _LIBCPP___FUNCTIONAL_NOT_FN_H
 
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/perfect_forward.h>
 #include <__utility/forward.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17

libcxx/include/__functional/perfect_forward.h

 #ifndef _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
 #define _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
 
 #include <__config>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <tuple>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17

libcxx/include/__hash_table

 
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__bit/countl.h>
 #include <__config>
 #include <__debug>
 #include <__functional/hash.h>
+#include <__functional/invoke.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__type_traits/can_extract_key.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/remove_const.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <cmath>
 #include <cstring>
 #include <initializer_list>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/shared_ptr.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 <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/disjunction.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_bounded_array.h>
+#include <__type_traits/is_move_constructible.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_unbounded_array.h>
+#include <__type_traits/nat.h>
+#include <__type_traits/negation.h>
+#include <__type_traits/remove_extent.h>
+#include <__type_traits/remove_reference.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <cstdlib> // abort
 #include <iosfwd>
 #include <new>
 #include <stdexcept>

libcxx/include/__mutex_base

 #define _LIBCPP___MUTEX_BASE
 
 #include <__chrono/duration.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__threading_support>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
 #include <ratio>
 #include <system_error>
 #include <time.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__random/clamp_to_integral.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H
 #define _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H
 
 #include <__config>
 #include <cmath>
 #include <limits>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__random/discard_block_engine.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
 #define _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
 
 #include <__config>
 #include <__random/is_seed_sequence.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_convertible.h>
 #include <__utility/move.h>
+#include <cstddef>
 #include <iosfwd>
 #include <limits>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__random/independent_bits_engine.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
 #define _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
 
 #include <__config>
 #include <__random/is_seed_sequence.h>
 #include <__random/log2.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_convertible.h>
 #include <__utility/move.h>
+#include <cstddef>
 #include <iosfwd>
 #include <limits>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__random/is_seed_sequence.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H
 #define _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Sseq, class _Engine>

libcxx/include/__random/linear_congruential_engine.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H
 #define _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H
 
 #include <__config>
 #include <__random/is_seed_sequence.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_unsigned.h>
 #include <cstdint>
 #include <iosfwd>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__random/mersenne_twister_engine.h

 #include <__algorithm/equal.h>
 #include <__algorithm/min.h>
 #include <__config>
 #include <__random/is_seed_sequence.h>
 #include <cstddef>
 #include <cstdint>
 #include <iosfwd>
 #include <limits>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__random/seed_seq.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_SEED_SEQ_H
 #define _LIBCPP___RANDOM_SEED_SEQ_H
 
 #include <__algorithm/copy.h>
 #include <__algorithm/fill.h>
 #include <__algorithm/max.h>
 #include <__config>
+#include <cstdint>
 #include <initializer_list>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/shuffle_order_engine.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H
 #define _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H
 
 #include <__algorithm/equal.h>
 #include <__config>
 #include <__random/is_seed_sequence.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_convertible.h>
 #include <__utility/move.h>
+#include <cstddef>
 #include <cstdint>
 #include <iosfwd>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__random/subtract_with_carry_engine.h

 #include <__algorithm/min.h>
 #include <__config>
 #include <__random/is_seed_sequence.h>
 #include <__random/linear_congruential_engine.h>
 #include <cstddef>
 #include <cstdint>
 #include <iosfwd>
 #include <limits>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__random/uniform_real_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
 
 #include <__config>
 #include <__random/generate_canonical.h>
 #include <__random/is_valid.h>
 #include <iosfwd>
 #include <limits>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__ranges/all.h

 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/owning_view.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/ref_view.h>
+#include <__type_traits/decay.h>
 #include <__utility/auto_cast.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/common_view.h

 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.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
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/copyable_box.h

 #include <__concepts/constructible.h>
 #include <__concepts/copyable.h>
 #include <__concepts/movable.h>
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
 #include <__utility/move.h>
 #include <optional>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/counted.h

 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/counted_iterator.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/subrange.h>
+#include <__type_traits/decay.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <cstddef>
 #include <span>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/drop_view.h

 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <type_traits>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__ranges/empty_view.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANGES_EMPTY_VIEW_H
 #define _LIBCPP___RANGES_EMPTY_VIEW_H
 
 #include <__config>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/view_interface.h>
-#include <type_traits>
+#include <__type_traits/is_object.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/filter_view.h

 #include <__ranges/concepts.h>
 #include <__ranges/copyable_box.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/iota_view.h

 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/unreachable_sentinel.h>
 #include <__ranges/copyable_box.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_nothrow_copy_constructible.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/type_identity.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
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/join_view.h

 #include <__ranges/concepts.h>
 #include <__ranges/empty.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/maybe_const.h>
 #include <__utility/forward.h>
 #include <optional>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Note: `join_view` is still marked experimental because there is an ABI-breaking change that affects `join_view` in

libcxx/include/__ranges/lazy_split_view.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H
 #define _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H
 
 #include <__algorithm/ranges_find.h>
 #include <__algorithm/ranges_mismatch.h>
+#include <__assert>
 #include <__concepts/constructible.h>
 #include <__concepts/convertible_to.h>
 #include <__concepts/derived_from.h>
 #include <__config>
 #include <__functional/bind_back.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/single_view.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/maybe_const.h>
+#include <__type_traits/remove_reference.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
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/non_propagating_cache.h

 #define _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H
 
 #include <__config>
 #include <__iterator/concepts.h>        // indirectly_readable
 #include <__iterator/iterator_traits.h> // iter_reference_t
 #include <__memory/addressof.h>
 #include <__utility/forward.h>
 #include <optional>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/owning_view.h

 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/move.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/range_adaptor.h

 #include <__concepts/invocable.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__functional/compose.h>
 #include <__functional/invoke.h>
 #include <__ranges/concepts.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
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/rbegin.h

 
 #include <__concepts/class_or_enum.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__ranges/access.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
 #include <__utility/auto_cast.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/ref_view.h

 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/is_object.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/rend.h

 #include <__concepts/class_or_enum.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__ranges/access.h>
 #include <__ranges/rbegin.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
 #include <__utility/auto_cast.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/reverse_view.h

 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/remove_cvref.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
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/single_view.h

 #ifndef _LIBCPP___RANGES_SINGLE_VIEW_H
 #define _LIBCPP___RANGES_SINGLE_VIEW_H
 
 #include <__concepts/constructible.h>
 #include <__config>
 #include <__ranges/copyable_box.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_object.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
-#include <type_traits>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/take_view.h

 #include <__ranges/concepts.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/maybe_const.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <type_traits>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__ranges/transform_view.h

 #include <__ranges/empty.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/maybe_const.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__ranges/zip_view.h

 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <tuple>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__split_buffer

 #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/swap_allocator.h>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/remove_reference.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <type_traits>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/any

 
 #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/unique_ptr.h>
+#include <__type_traits/add_const.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/aligned_storage.h>
+#include <__type_traits/alignment_of.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_function.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.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>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 namespace std {

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

libcxx/include/array

 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/swap_ranges.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/reverse_iterator.h>
 #include <__tuple_dir/sfinae_helpers.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_move_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/remove_cv.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <stdexcept>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
 #  include <iterator>
+#  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_ARRAY

libcxx/include/bitset

 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_BITSET

libcxx/include/charconv

 #include <__charconv/from_chars_result.h>
 #include <__charconv/tables.h>
 #include <__charconv/to_chars_base_10.h>
 #include <__charconv/to_chars_result.h>
 #include <__config>
 #include <__debug>
 #include <__errc>
 #include <__memory/addressof.h>
+#include <__type_traits/is_unsigned.h>
 #include <__type_traits/make_32_64_or_128_bit.h>
+#include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>
 #include <cmath> // for log2f
 #include <cstdint>
 #include <cstdlib>
 #include <limits>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstring>
 #  include <iosfwd>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_CHARCONV

libcxx/include/complex

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cmath>
 #include <iosfwd>
 #include <stdexcept>
-#include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream> // for std::basic_ostringstream
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
_LIBCPP_HIDE_FROM_ABI constexpr complex<float> operator""if(unsigned long long __im)
         return { 0.0f, static_cast<float>(__im) };
     }
   } // namespace complex_literals
 } // namespace literals
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
+#endif
+
 #endif // _LIBCPP_COMPLEX

libcxx/include/deque

 #include <__iterator/segmented_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 <__type_traits/is_same.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <limits>
 #include <stdexcept>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

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

libcxx/include/experimental/__memory

 // -*- 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_EXPERIMENTAL___MEMORY
 #define _LIBCPP_EXPERIMENTAL___MEMORY
 
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_same.h>
 #include <experimental/__config>
 #include <experimental/utility> // for erased_type
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
 template <

libcxx/include/experimental/memory_resource

 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__memory/allocator_traits.h>
+#include <__type_traits/aligned_storage.h>
 #include <__utility/move.h>
 #include <cstddef>
 #include <cstdlib>
 #include <experimental/__config>
 #include <experimental/__memory>
 #include <limits>
 #include <new>
 #include <stdexcept>
 #include <tuple>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

 #  include <atomic>
 #  include <climits>
 #  include <concepts>
 #  include <cstring>
 #  include <ctime>
 #  include <iterator>
 #  include <memory>
 #  include <ratio>
+#  include <type_traits>
 #  include <variant>
 #endif
 
 #endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */

libcxx/include/experimental/propagate_const

 
 } // namespace std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/operations.h>
 #include <__fwd/hash.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_function.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_pointer.h>
+#include <__type_traits/remove_reference.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
+#include <cstddef>
 #include <experimental/__config>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
   {
     return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
   }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
+#endif
+
 #endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST

libcxx/include/ext/hash_map

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
 #include <algorithm>
 #include <ext/__hash>
 #include <functional>
 #include <stdexcept>
-#include <type_traits>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
 #else
 #   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
 #endif
 #endif
operator!=(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
     return !(__x == __y);
 }
 
 } // namespace __gnu_cxx
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_HASH_MAP

libcxx/include/ext/hash_set

operator!=(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
     return !(__x == __y);
 }
 
 } // namespace __gnu_cxx
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_HASH_SET

libcxx/include/forward_list

 #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/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <limits>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

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

libcxx/include/functional

 #include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
 #include <__functional/unary_negate.h>
 #include <__functional/unwrap_ref.h>
 #include <__utility/forward.h>
 #include <exception>
 #include <memory> // TODO: find out why removing this breaks the modules build
-#include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <tuple>
+#  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_FUNCTIONAL

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/shared_ptr.h>
+#include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
+#include <__type_traits/aligned_storage.h>
+#include <__type_traits/alignment_of.h>
 #include <__type_traits/strip_signature.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/istream

 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/istreambuf_iterator.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <ostream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/list

 #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/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <cstring>
 #include <limits>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

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

libcxx/include/locale

 #include <__config>
 #include <__debug>
 #include <__iterator/access.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
 #include <__locale>
 #include <__memory/unique_ptr.h>
+#include <__type_traits/make_unsigned.h>
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <ios>
 #include <limits>
 #include <new>
 #include <streambuf>
 #include <version>

libcxx/include/map

 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <tuple>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
+#  include <type_traits>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_MAP

libcxx/include/optional

 #include <__availability>
 #include <__concepts/invocable.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__memory/construct_at.h>
 #include <__tuple_dir/sfinae_helpers.h>
+#include <__type_traits/is_trivially_copy_assignable.h>
+#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/is_trivially_move_assignable.h>
+#include <__type_traits/is_trivially_move_constructible.h>
+#include <__type_traits/negation.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [optional.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 #  include <atomic>
 #  include <climits>
 #  include <concepts>
 #  include <ctime>
 #  include <iterator>
 #  include <memory>
 #  include <ratio>
 #  include <tuple>
+#  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #  include <variant>
 #endif
 
 #endif // _LIBCPP_OPTIONAL

libcxx/include/ostream

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
 #include <bitset>
 #include <ios>
 #include <locale>
 #include <new>
 #include <streambuf>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/queue

 #include <__algorithm/push_heap.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <deque>
-#include <type_traits>
 #include <vector>
 #include <version>
 
 // standard-mandated includes
 
 // [queue.syn]
 #include <compare>
 #include <initializer_list>

 {
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_QUEUE

libcxx/include/ranges

 #include <__ranges/split_view.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/take_while_view.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/views.h>
 #include <__ranges/zip_view.h>
-#include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #include <__ranges/istream_view.h>
 #endif
 
 // standard-mandated includes
 
 // [ranges.syn]
 #include <compare>
 #include <initializer_list>
 #include <iterator>
 
 // [tuple.helper]
 #include <__tuple_dir/tuple_element.h>
 #include <__tuple_dir/tuple_size.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
+#endif
+
 #endif // _LIBCPP_RANGES

libcxx/include/set

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_SET

libcxx/include/span

 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <array>        // for array
 #include <cstddef>      // for byte
 #include <limits>
-#include <type_traits>  // for remove_cv, etc
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_SPAN

libcxx/include/stack

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
+#include <__type_traits/is_same.h>
 #include <__utility/forward.h>
 #include <deque>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [stack.syn]
 #include <compare>
 #include <initializer_list>
 

 {
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_STACK

libcxx/include/string

 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__type_traits/is_allocator.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_standard_layout.h>
+#include <__type_traits/is_trivial.h>
 #include <__type_traits/noexcept_move_assign_container.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <cstdint>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <stdexcept>
 #include <string_view>
-#include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif
 
 // standard-mandated includes
 

 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
 #  include <new>
+#  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #  include <vector>
 #endif
 
 #endif // _LIBCPP_STRING

libcxx/include/string_view

 #include <__iterator/reverse_iterator.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__string/char_traits.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_standard_layout.h>
+#include <__type_traits/is_trivial.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
+#include <__type_traits/type_identity.h>
 #include <iosfwd>
 #include <limits>
 #include <stdexcept>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_STRING_VIEW

libcxx/include/system_error

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__errc>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__memory/addressof.h>
 #include <stdexcept>
 #include <string>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [system.error.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
private:
     static string __init(const error_code&, string);
 };
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS
 void __throw_system_error(int __ev, const char* __what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
+#endif
+
 #endif // _LIBCPP_SYSTEM_ERROR

libcxx/include/thread

 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstddef>
 #include <iosfwd>
 #include <system_error>
 #include <tuple>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [thread.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/typeinfo

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__type_traits/is_constant_evaluated.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <exception>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <vcruntime_typeinfo.h>
 #else

 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     throw bad_cast();
 #else
     _VSTD::abort();
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
+#endif
+
 #endif // __LIBCPP_TYPEINFO

libcxx/include/unordered_map

 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <bit>
 #  include <concepts>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_UNORDERED_MAP

libcxx/include/unordered_set

 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_UNORDERED_SET

libcxx/include/variant

 #include <__type_traits/is_trivially_copy_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
 #include <__type_traits/is_trivially_move_assignable.h>
 #include <__type_traits/is_trivially_move_constructible.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/remove_const.h>
 #include <__type_traits/type_identity.h>
 #include <__type_traits/void_t.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__variant/monostate.h>
 #include <exception>
 #include <initializer_list>
 #include <limits>

libcxx/include/vector

 #include <__memory/allocate_at_least.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/temp_value.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/noexcept_move_assign_container.h>
+#include <__type_traits/type_identity.h>
 #include <__utility/exception_guard.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <climits>
 #include <cstdlib>
 #include <cstring>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>
 #include <stdexcept>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.range]
 #include <__iterator/access.h>
 #include <__iterator/data.h>
 #include <__iterator/empty.h>

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

libcxx/test/libcxx/containers/sequences/vector.bool/trivial_for_purposes_of_call.pass.cpp

 // The definition of 'non-trivial for the purposes of calls':
 //   A type is considered non-trivial for the purposes of calls if:
 //     * it has a non-trivial copy constructor, move constructor, or
 //       destructor, or
 //     * all of its copy and move constructors are deleted.
 
 // UNSUPPORTED: c++03
 
-#include <vector>
 #include <cassert>
-
-#include "test_macros.h"
+#include <type_traits>
+#include <vector>
 
 template <class T>
 using IsTrivialForCall = std::integral_constant<bool,
   std::is_trivially_copy_constructible<T>::value &&
   std::is_trivially_move_constructible<T>::value &&
   std::is_trivially_destructible<T>::value
   // Ignore the all-deleted case, it shouldn't occur here.
   >;

libcxx/test/libcxx/language.support/support.dynamic/new_faligned_allocation.pass.cpp

 
 // Libcxx when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
+#include <cassert>
 #include <new>
-#include <typeinfo>
 #include <string>
-#include <cassert>
+#include <type_traits>
+#include <typeinfo>
 
 #include "test_macros.h"
 
 static void test_allocations(size_t size, size_t alignment) {
   {
     void* ptr = ::operator new(size, std::align_val_t(alignment));
     assert(ptr);
     assert(reinterpret_cast<std::uintptr_t>(ptr) % alignment == 0);

libcxx/test/libcxx/ranges/range.adaptors/range.join/segmented_iterator.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: !c++experimental
 
 #include <ranges>
+#include <utility>
 #include <vector>
 
 using JoinView = decltype(std::views::join(std::declval<std::vector<std::vector<int>>&>()));
 using JoinIter = std::ranges::iterator_t<JoinView>;
 static_assert(std::__is_segmented_iterator<JoinIter>::value);

libcxx/test/libcxx/transitive_includes/cxx03.csv

 functional stdexcept
 functional tuple
 functional type_traits
 functional typeinfo
 functional unordered_map
 functional utility
 functional vector
 functional version
+future atomic
 future chrono
 future cstddef
+future cstdint
+future cstdlib
+future cstring
 future exception
+future initializer_list
+future iosfwd
 future limits
 future mutex
 future new
 future ratio
+future stdexcept
 future system_error
 future thread
 future type_traits
+future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios atomic
 ios cctype
 ios concepts
 ios cstddef

libcxx/test/libcxx/transitive_includes/cxx11.csv

 functional stdexcept
 functional tuple
 functional type_traits
 functional typeinfo
 functional unordered_map
 functional utility
 functional vector
 functional version
+future atomic
 future chrono
 future cstddef
+future cstdint
+future cstdlib
+future cstring
 future exception
+future initializer_list
+future iosfwd
 future limits
 future mutex
 future new
 future ratio
+future stdexcept
 future system_error
 future thread
 future type_traits
+future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios atomic
 ios cctype
 ios concepts
 ios cstddef

libcxx/test/libcxx/transitive_includes/cxx14.csv

 functional stdexcept
 functional tuple
 functional type_traits
 functional typeinfo
 functional unordered_map
 functional utility
 functional vector
 functional version
+future atomic
 future chrono
 future cstddef
+future cstdint
+future cstdlib
+future cstring
 future exception
+future initializer_list
+future iosfwd
 future limits
 future mutex
 future new
 future ratio
+future stdexcept
 future system_error
 future thread
 future type_traits
+future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios atomic
 ios cctype
 ios concepts
 ios cstddef

libcxx/test/libcxx/transitive_includes/cxx17.csv

 functional stdexcept
 functional tuple
 functional type_traits
 functional typeinfo
 functional unordered_map
 functional utility
 functional vector
 functional version
+future atomic
 future chrono
 future cstddef
+future cstdint
+future cstdlib
+future cstring
 future exception
+future initializer_list
+future iosfwd
 future limits
 future mutex
 future new
 future ratio
+future stdexcept
 future system_error
 future thread
 future type_traits
+future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios atomic
 ios cctype
 ios concepts
 ios cstddef

libcxx/test/libcxx/transitive_includes/cxx20.csv

 functional stdexcept
 functional tuple
 functional type_traits
 functional typeinfo
 functional unordered_map
 functional utility
 functional vector
 functional version
+future atomic
 future cstddef
+future cstdint
+future cstdlib
+future cstring
 future exception
+future initializer_list
+future iosfwd
 future limits
 future mutex
 future new
 future ratio
+future stdexcept
 future system_error
 future thread
 future type_traits
+future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios atomic
 ios cctype
 ios concepts
 ios cstddef

libcxx/test/libcxx/transitive_includes/cxx2b.csv

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

 bitset cstdlib
 bitset cstring
 bitset initializer_list
 bitset iosfwd
 bitset limits
 bitset new
 bitset stdexcept
 bitset string
-bitset type_traits
 bitset version
 ccomplex complex
 charconv cerrno
 charconv cmath
 charconv cstddef
 charconv cstdint
 charconv cstdlib
 charconv initializer_list
 charconv limits
-charconv type_traits
 chrono array
 chrono charconv
 chrono cmath
 chrono compare
 chrono cstddef
 chrono cstdint
 chrono cstdlib
 chrono ctime
 chrono initializer_list
 chrono limits
 chrono locale
 chrono optional
 chrono ostream
 chrono ratio
 chrono sstream
 chrono stdexcept
 chrono string
 chrono string_view
 chrono tuple
-chrono type_traits
 chrono vector
 chrono version
 cinttypes cstdint
 cmath version
 codecvt cctype
 codecvt cstddef
 codecvt cstdint
 codecvt cstring
 codecvt mutex
 codecvt string
 codecvt version
 compare cmath
 compare cstddef
 compare cstdint
 compare limits
 compare version
 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
-complex type_traits
 complex version
 concepts cstddef
 concepts version
 condition_variable atomic
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring

 deque cstdint
 deque cstdlib
 deque cstring
 deque initializer_list
 deque limits
 deque new
 deque stdexcept
 deque tuple
-deque type_traits
 deque version
 exception cstddef
 exception cstdlib
 exception version
 execution version
 expected cstddef
 expected cstdlib
 expected exception

 experimental/map map
 experimental/memory_resource cstddef
 experimental/memory_resource cstdlib
 experimental/memory_resource experimental/utility
 experimental/memory_resource limits
 experimental/memory_resource new
 experimental/memory_resource stdexcept
 experimental/memory_resource tuple
-experimental/memory_resource type_traits
 experimental/propagate_const cstddef
-experimental/propagate_const type_traits
 experimental/regex experimental/memory_resource
 experimental/regex experimental/string
 experimental/regex regex
 experimental/set experimental/memory_resource
 experimental/set set
 experimental/simd array
 experimental/simd cstddef
 experimental/simd tuple

 ext/hash_map cstdint
 ext/hash_map cstring
 ext/hash_map functional
 ext/hash_map initializer_list
 ext/hash_map limits
 ext/hash_map new
 ext/hash_map stdexcept
 ext/hash_map string
-ext/hash_map type_traits
 ext/hash_set algorithm
 ext/hash_set cmath
 ext/hash_set cstddef
 ext/hash_set cstdint
 ext/hash_set cstring
 ext/hash_set functional
 ext/hash_set initializer_list
 ext/hash_set limits
 ext/hash_set new
 ext/hash_set string
-ext/hash_set type_traits
 filesystem cerrno
 filesystem compare
 filesystem cstddef
 filesystem cstdint
 filesystem cstdlib
 filesystem ctime
 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
 filesystem system_error
-filesystem type_traits
 filesystem version
 format array
 format charconv
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits

 forward_list cstdint
 forward_list cstdlib
 forward_list cstring
 forward_list initializer_list
 forward_list limits
 forward_list new
 forward_list stdexcept
 forward_list tuple
-forward_list type_traits
 forward_list version
 fstream cctype
 fstream cstddef
 fstream cstdint
 fstream cstdio
 fstream cstdlib
 fstream cstring
 fstream filesystem

 functional exception
 functional initializer_list
 functional iosfwd
 functional limits
 functional memory
 functional new
 functional stdexcept
 functional tuple
-functional type_traits
 functional typeinfo
 functional unordered_map
 functional vector
 functional version
+future atomic
 future cstddef
+future cstdint
+future cstdlib
+future cstring
 future exception
+future initializer_list
+future iosfwd
 future limits
 future mutex
 future new
 future ratio
+future stdexcept
 future system_error
 future thread
+future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios atomic
 ios cctype
 ios cstddef
 ios cstdint

 list cstdint
 list cstdlib
 list cstring
 list initializer_list
 list limits
 list new
 list stdexcept
 list tuple
-list type_traits
 list version
 locale cctype
 locale cstddef
 locale cstdint
 locale cstdio
 locale cstdlib
 locale cstring
 locale ctime

 map cstddef
 map cstdlib
 map initializer_list
 map limits
 map new
 map optional
 map stdexcept
 map tuple
-map type_traits
 map version
 memory atomic
 memory compare
 memory cstddef
 memory cstdint
 memory cstdlib
 memory cstring
 memory initializer_list

 optional compare
 optional cstddef
 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 typeinfo
 ostream version
 queue compare
 queue cstddef
 queue cstdlib
 queue deque
 queue initializer_list
 queue limits
-queue type_traits
 queue vector
 queue version
 random cmath
 random cstddef
 random cstdint
 random cstdlib
 random initializer_list
 random iosfwd
 random limits
 random numeric
 random string
-random type_traits
 random vector
 random version
 ranges compare
 ranges cstddef
 ranges cstdlib
 ranges initializer_list
 ranges iosfwd
 ranges iterator
 ranges limits
 ranges new
 ranges optional
 ranges span
 ranges tuple
-ranges type_traits
 ranges variant
 ranges version
 ratio climits
 ratio cstdint
 ratio version
 regex cctype
 regex compare
 regex cstddef

 set cstddef
 set cstdlib
 set initializer_list
 set limits
 set new
 set optional
 set stdexcept
 set tuple
-set type_traits
 set version
 shared_mutex cstddef
 shared_mutex ctime
 shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex system_error
 shared_mutex version
 source_location cstdint
 source_location version
 span array
 span cstddef
 span initializer_list
 span limits
-span type_traits
 span version
 sstream cstddef
 sstream istream
 sstream ostream
 sstream string
 sstream version
 stack compare
 stack cstddef
 stack deque
 stack initializer_list
-stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef
 string cstdint
 string cstdio
 string cstdlib
 string cstring
 string cwchar
 string initializer_list
 string iosfwd
 string limits
 string new
 string stdexcept
 string string_view
 string tuple
-string type_traits
 string version
 string_view compare
 string_view cstddef
 string_view cstdint
 string_view cstdio
 string_view cstdlib
 string_view cstring
 string_view cwchar
 string_view initializer_list
 string_view iosfwd
 string_view limits
 string_view stdexcept
-string_view type_traits
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare
 system_error cstddef
 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
-system_error type_traits
 system_error version
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread iosfwd
 thread limits
 thread new
 thread ratio
 thread system_error
 thread tuple
-thread type_traits
 thread version
 tuple compare
 tuple cstddef
 tuple version
 type_traits cstddef
 type_traits cstdint
 type_traits version
 typeindex compare
 typeindex typeinfo
 typeindex version
 typeinfo cstddef
 typeinfo cstdint
 typeinfo cstdlib
 typeinfo exception
-typeinfo type_traits
 unordered_map cmath
 unordered_map compare
 unordered_map cstddef
 unordered_map cstdint
 unordered_map cstdlib
 unordered_map cstring
 unordered_map initializer_list
 unordered_map limits
 unordered_map new
 unordered_map optional
 unordered_map stdexcept
 unordered_map tuple
-unordered_map type_traits
 unordered_map version
 unordered_set cmath
 unordered_set compare
 unordered_set cstddef
 unordered_set cstdint
 unordered_set cstdlib
 unordered_set cstring
 unordered_set initializer_list
 unordered_set limits
 unordered_set new
 unordered_set optional
 unordered_set stdexcept
 unordered_set tuple
-unordered_set type_traits
 unordered_set version
 utility compare
 utility cstddef
 utility initializer_list
 utility limits
 utility version
 valarray cmath
 valarray cstddef

 vector cstdlib
 vector cstring
 vector initializer_list
 vector iosfwd
 vector limits
 vector new
 vector stdexcept
 vector tuple
-vector type_traits
 vector version

libcxx/test/std/containers/sequences/array/array.special/swap.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // template <class T, size_t N> void swap(array<T,N>& x, array<T,N>& y);
 
 #include <array>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 struct NonSwappable {
     TEST_CONSTEXPR NonSwappable() { }
 private:
     NonSwappable(NonSwappable const&);
     NonSwappable& operator=(NonSwappable const&);

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // <iterator>
 // template <class C> constexpr auto ssize(const C& c)
 //     -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;                    // C++20
 // template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20
 
-#include <iterator>
-#include <cassert>
-#include <vector>
 #include <array>
-#include <list>
+#include <cassert>
+#include <cstdint>
 #include <initializer_list>
-#include <string_view>
+#include <iterator>
 #include <limits>
+#include <list>
+#include <string_view>
+#include <type_traits>
+#include <vector>
 
 #include "test_macros.h"
 
 // Ignore warning about std::numeric_limits comparisons being tautological.
 TEST_GCC_DIAGNOSTIC_IGNORED("-Wtype-limits")
 
 struct short_container {
     uint16_t size() const { return 60000; } // not noexcept

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template<class I>
 // unspecified iter_move;
 
-#include <iterator>
-
-#include <array>
 #include <algorithm>
+#include <array>
 #include <cassert>
+#include <iterator>
+#include <type_traits>
 #include <utility>
 
 #include "../unqualified_lookup_wrapper.h"
 
 using IterMoveT = decltype(std::ranges::iter_move);
 
 // Wrapper around an iterator for testing `iter_move` when an unqualified call to `iter_move` isn't
 // possible.

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // class istream_iterator
 
 // istream_iterator(); // constexpr since C++11
 // C++17 says: If is_trivially_default_constructible_v<T> is true, then this
 //    constructor is a constexpr constructor.
 
-#include <iterator>
 #include <cassert>
+#include <iterator>
 #include <string>
+#include <type_traits>
 
 #include "test_macros.h"
 
 struct S { S(); }; // not constexpr
 
 #if TEST_STD_VER > 14
 template <typename T, bool isTrivial = std::is_trivially_default_constructible_v<T>>
 struct test_trivial {

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp

 
 // <random>
 
 // template<class IntType = int>
 // class binomial_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
-#include <random>
+#include <cassert>
+#include <cstdint>
 #include <numeric>
+#include <random>
+#include <type_traits>
 #include <vector>
-#include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
 T sqr(T x) {
     return x * x;
 }
 

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp

 
 // <random>
 
 // template<class IntType = int>
 // class geometric_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
-#include <random>
+#include <cassert>
+#include <cstdint>
 #include <numeric>
+#include <random>
 #include <vector>
-#include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
 T sqr(T x) {
     return x * x;
 }
 

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp

 
 // <random>
 
 // template<class IntType = int>
 // class poisson_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
-#include <random>
-
 #include <cassert>
 #include <cmath>
+#include <cstdint>
 #include <limits>
-#include <vector>
 #include <numeric>
+#include <random>
+#include <vector>
 
 #include "test_macros.h"
 
 template <class T>
 T sqr(T x) {
   return x * x;
 }
 

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp

 
 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
+#include <cassert>
+#include <cstdint>
 #include <random>
 #include <vector>
-#include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
 void tests() {
     typedef long long Frequency;
     {
         typedef std::discrete_distribution<T> D;

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

 
 // <random>
 
 // template<class _IntType = int>
 // class uniform_int_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
-#include <random>
 #include <cassert>
 #include <climits>
 #include <cstddef>
+#include <cstdint>
 #include <limits>
 #include <numeric>
+#include <random>
 #include <vector>
 
 #include "test_macros.h"
 
 // The __int128 conversions to/from floating point crash on MinGW on x86_64.
 // This is fixed in Clang 14 by https://reviews.llvm.org/D110413.
 #if defined(__x86_64__) && defined(__MINGW32__) && defined(__clang_major__) && __clang_major__ < 14
  #define TEST_BUGGY_I128_FP

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/int128.pass.cpp

 
 // <random>
 
 // template<class _IntType = int>
 // class uniform_int_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
-#include <random>
 
 #include <cassert>
+#include <cstdint>
 #include <limits>
+#include <random>
 
 #include "test_macros.h"
 
 int main(int, char**) {
 
 #ifndef TEST_HAS_NO_INT128
 
   // Test that values outside of the 64-bit range can be produced.

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/ctor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 // std::ranges::as_rvalue_view::as_rvalue_view(...)
 
 #include <cassert>
 #include <ranges>
+#include <type_traits>
 #include <vector>
 
 struct DefaultConstructibleView : std::ranges::view_base {
   int* begin() const;
   int* end() const;
 
   int i_ = 23;
 };

libcxx/test/std/ranges/range.adaptors/range.take/ctor.default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // take_view() requires default_initializable<V> = default;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
 struct DefaultConstructible : std::ranges::view_base {
   constexpr DefaultConstructible() : begin_(buff), end_(buff + 8) { }
   constexpr int const* begin() const { return begin_; }
   constexpr int const* end() const { return end_; }
 private:

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // constexpr explicit iota_view(W value);
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "types.h"
 
 struct SomeIntComparable {
   using difference_type = int;
 
   SomeInt value_;

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/ctor.value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // constexpr explicit iterator(W value);
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   {
     using Iter = std::ranges::iterator_t<std::ranges::iota_view<int>>;
     auto iter = Iter(42);

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/decrement.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // constexpr iterator& operator--() requires decrementable<W>;
 // constexpr iterator operator--(int) requires decrementable<W>;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 template<class T>
 concept Decrementable =
   requires(T i) {
     --i;

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/increment.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // constexpr iterator& operator++();
 // constexpr void operator++(int);
 // constexpr iterator operator++(int) requires incrementable<W>;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   {
     std::ranges::iota_view<int> io(0);
     auto iter1 = io.begin();

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/member_typedefs.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // Test iterator category and iterator concepts.
 
 #include <cassert>
 #include <cstdint>
 #include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 struct Decrementable {
   using difference_type = int;
 
   auto operator<=>(const Decrementable&) const = default;

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/minus.pass.cpp

 // friend constexpr iterator operator-(iterator i, difference_type n)
 //   requires advanceable<W>;
 // friend constexpr difference_type operator-(const iterator& x, const iterator& y)
 //   requires advanceable<W>;
 
 #include <cassert>
 #include <cstdint>
 #include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 // If we're compiling for 32 bit or windows, int and long are the same size, so long long is the correct difference type.
 #if INTPTR_MAX == INT32_MAX || defined(_WIN32)
 using IntDiffT = long long;
 #else

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/minus_eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // constexpr iterator& operator-=(difference_type n)
 //   requires advanceable<W>;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   // When "_Start" is signed integer like.
   {
     std::ranges::iota_view<int> io(0);

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/plus.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // friend constexpr iterator operator+(iterator i, difference_type n)
 //   requires advanceable<W>;
 // friend constexpr iterator operator+(difference_type n, iterator i)
 //   requires advanceable<W>;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   // When "_Start" is signed integer like.
   {
     std::ranges::iota_view<int> io(0);

libcxx/test/std/ranges/range.factories/range.iota.view/iterator/plus_eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // constexpr iterator& operator+=(difference_type n)
 //   requires advanceable<W>;
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   // When "_Start" is signed integer like.
   {
     std::ranges::iota_view<int> io(0);

libcxx/test/std/ranges/range.factories/range.iota.view/sentinel/ctor.value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // constexpr explicit sentinel(Bound bound);
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "../types.h"
 
 constexpr bool test() {
   {
     using Sent = std::ranges::sentinel_t<std::ranges::iota_view<int, IntSentinelWith<int>>>;
     using Iter = std::ranges::iterator_t<std::ranges::iota_view<int, IntSentinelWith<int>>>;

libcxx/test/std/ranges/range.factories/range.iota.view/views_iota.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // views::iota
 
-#include <ranges>
 #include <cassert>
 #include <concepts>
+#include <ranges>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "types.h"
 
 template<class T, class U>
 constexpr void testType(U u) {
   // Test that this generally does the right thing.
   // Test with only one argument.

libcxx/test/std/strings/basic.string.literals/noexcept.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 
 #include <string>
+#include <utility>
 
 #include "test_macros.h"
 
 static_assert(!noexcept(std::operator""s(std::declval<const char*>(), std::declval<int>())), "");
 #ifndef TEST_HAS_NO_CHAR8_T
 static_assert(!noexcept(std::operator""s(std::declval<const char8_t*>(), std::declval<int>())), "");
 #endif
 static_assert(!noexcept(std::operator""s(std::declval<const char16_t*>(), std::declval<int>())), "");
 static_assert(!noexcept(std::operator""s(std::declval<const char32_t*>(), std::declval<int>())), "");
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert(!noexcept(std::operator""s(std::declval<const wchar_t*>(), std::declval<int>())), "");
 #endif

libcxx/test/std/strings/string.view/string.view.io/stream_insert_decl_present.compile.pass.cpp

 
 // <string_view>
 
 // template<class charT, class traits, class Allocator>
 //   basic_ostream<charT, traits>&
 //   operator<<(basic_ostream<charT, traits>& os,
 //              const basic_string_view<charT,traits> str);
 
-#include <string_view>
 #include <iosfwd>
+#include <string_view>
+#include <utility>
 
 template <class SV, class = void>
 struct HasDecl : std::false_type {};
 template <class SV>
 struct HasDecl<SV, decltype(static_cast<void>(std::declval<std::ostream&>() << std::declval<SV&>()))> : std::true_type {};
 
 static_assert(HasDecl<std::string_view>::value, "streaming operator declaration not present");

libcxx/test/std/utilities/charconv/charconv.syn/chars_format.pass.cpp

 // Bitmask type
 // enum class chars_format {
 //   scientific = unspecified,
 //   fixed = unspecified,
 //   hex = unspecified,
 //   general = fixed | scientific
 // };
 
-#include <charconv>
 #include <cassert>
+#include <charconv>
+#include <type_traits>
 
 #include "test_macros.h"
 
 constexpr bool test() {
   using cf = std::chars_format;
   using ut = std::underlying_type<cf>::type;
 
   {

libcxx/test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // bitset(string, pos, n, zero, one); // constexpr since C++23
 
-#include <bitset>
 #include <algorithm> // for 'min' and 'max'
+#include <bitset>
 #include <cassert>
 #include <stdexcept> // for 'invalid_argument'
 #include <string>
+#include <type_traits>
 
 #include "test_macros.h"
 
 template <std::size_t N>
 TEST_CONSTEXPR_CXX23 void test_string_ctor() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   if (!TEST_IS_CONSTANT_EVALUATED) {
     try {

libcxx/test/support/filesystem_test_helper.h

 #endif
 
 #include <cassert>
 #include <chrono>
 #include <cstdint>
 #include <cstdio> // for printf
 #include <string>
 #include <system_error>
+#include <type_traits>
 #include <vector>
 
 #include "assert_macros.h"
 #include "make_string.h"
 #include "test_macros.h"
 #include "format_string.h"
 
 // For creating socket files

libcxxabi/src/demangle/ItaniumDemangle.h

 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <new>
+#include <type_traits>
 #include <utility>
 
 DEMANGLE_NAMESPACE_BEGIN
 
 template <class T, size_t N> class PODSmallVector {
   static_assert(std::is_pod<T>::value,
                 "T is required to be a plain old data type");