[libc++] Granularize <type_traits> includes in <iterator>

[philnik]

Try to fix CI

[Mordante]

LGTM, thanks again for the cleanup!

[philnik]

Try to fix CI

[philnik]

Rebased

libcxx/include/__algorithm/shuffle.h

 
 #include <__algorithm/iterator_operations.h>
 #include <__config>
 #include <__debug>
 #include <__iterator/iterator_traits.h>
 #include <__random/uniform_int_distribution.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
+#include <__utility/swap.h>
 #include <cstddef>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__algorithm/sort.h

 #include <__config>
 #include <__debug>
 #include <__debug_utils/randomize_range.h>
 #include <__functional/operations.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/destruct_n.h>
 #include <__memory/unique_ptr.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_arithmetic.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <climits>
+#include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Wraps an algorithm policy tag and a comparator in a single struct, used to pass the policy tag around without

libcxx/include/__debug

 // -*- 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___DEBUG
 #define _LIBCPP___DEBUG
 
 #include <__assert>
 #include <__config>
+#include <__type_traits/is_constant_evaluated.h>
 #include <cstddef>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_ENABLE_DEBUG_MODE) && !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY)
 # define _LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY
 #endif

libcxx/include/__iterator/bounded_iter.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___ITERATOR_BOUNDED_ITER_H
 #define _LIBCPP___ITERATOR_BOUNDED_ITER_H
 
 #include <__assert>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/pointer_traits.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_convertible.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
 
 // Iterator wrapper that carries the valid range it is allowed to access.

libcxx/include/__iterator/common_iterator.h

 #include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
+#include <__type_traits/is_pointer.h>
+#include <__utility/declval.h>
 #include <variant>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__iterator/counted_iterator.h

 #include <__iterator/concepts.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/pointer_traits.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/conditional.h>
 #include <__utility/move.h>
 #include <compare>
-#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/__iterator/move_iterator.h

 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_sentinel.h>
 #include <__iterator/readable_traits.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_same.h>
+#include <__utility/declval.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 > 17

libcxx/include/__iterator/projected.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___ITERATOR_PROJECTED_H
 #define _LIBCPP___ITERATOR_PROJECTED_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
-#include <type_traits>
+#include <__type_traits/remove_cvref.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__iterator/size.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___ITERATOR_SIZE_H
 #define _LIBCPP___ITERATOR_SIZE_H
 
 #include <__config>
+#include <__type_traits/common_type.h>
+#include <__type_traits/make_signed.h>
 #include <cstddef>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/__iterator/wrap_iter.h

 #ifndef _LIBCPP___ITERATOR_WRAP_ITER_H
 #define _LIBCPP___ITERATOR_WRAP_ITER_H
 
 #include <__config>
 #include <__debug>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
-#include <type_traits>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_convertible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Iter>

libcxx/include/__memory/uses_allocator_construction.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_USES_ALLOCATOR_CONSTRUCTION_H
 #define _LIBCPP___MEMORY_USES_ALLOCATOR_CONSTRUCTION_H
 
 #include <__config>
 #include <__memory/construct_at.h>
 #include <__memory/uses_allocator.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/remove_cv.h>
+#include <__utility/declval.h>
 #include <__utility/pair.h>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__tree

 // -*- 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___TREE
 #define _LIBCPP___TREE
 
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__config>
 #include <__debug>
+#include <__functional/invoke.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.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_nothrow_copy_constructible.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/is_swappable.h>
+#include <__type_traits/remove_const_ref.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <limits>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/experimental/iterator

template <class charT, class traits, class DelimT>
     } // inline namespace fundamentals_v2
   } // namespace experimental
 } // namespace std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__memory/addressof.h>
+#include <__type_traits/decay.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <experimental/__config>
 #include <iosfwd> // char_traits
 #include <iterator>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/fstream

 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <iosfwd>
 #  include <limits>
 #  include <new>
 #  include <stdexcept>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_FSTREAM

libcxx/include/iterator

 #include <__iterator/size.h>
 #include <__iterator/sortable.h>
 #include <__iterator/unreachable_sentinel.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <cstddef>
 #include <initializer_list>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [iterator.synopsis]
 #include <compare>
 #include <concepts>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <exception>
 #  include <new>
+#  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_ITERATOR

libcxx/include/locale

 // NOLINTEND(libcpp-robust-against-adl)
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdarg>
 #  include <iterator>
 #  include <stdexcept>
+#  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_LOCALE

libcxx/include/module.modulemap.in

module __functional {
       module binder2nd                  { private header "__functional/binder2nd.h" }
       module boyer_moore_searcher       { private header "__functional/boyer_moore_searcher.h" }
       module compose                    { private header "__functional/compose.h" }
       module default_searcher           { private header "__functional/default_searcher.h" }
       module function                   { private header "__functional/function.h" }
       module hash                       { private header "__functional/hash.h" }
       module hash_fwd                   { private header "__fwd/hash.h" }
       module identity                   { private header "__functional/identity.h" }
-      module invoke                     { private header "__functional/invoke.h" }
+      module invoke                     {
+        private header "__functional/invoke.h"
+        export type_traits
+      }
       module is_transparent             { private header "__functional/is_transparent.h" }
       module mem_fn                     { private header "__functional/mem_fn.h" }
       module mem_fun_ref                { private header "__functional/mem_fun_ref.h" }
       module not_fn                     { private header "__functional/not_fn.h" }
       module operations                 { private header "__functional/operations.h" }
       module perfect_forward            { private header "__functional/perfect_forward.h" }
       module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
       module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
module type_traits {
     module is_class                            { private header "__type_traits/is_class.h" }
     module is_compound                         { private header "__type_traits/is_compound.h" }
     module is_const                            { private header "__type_traits/is_const.h" }
     module is_constant_evaluated               { private header "__type_traits/is_constant_evaluated.h" }
     module is_constructible                    { private header "__type_traits/is_constructible.h" }
     module is_convertible                      { private header "__type_traits/is_convertible.h" }
     module is_copy_assignable                  { private header "__type_traits/is_copy_assignable.h" }
     module is_copy_constructible               { private header "__type_traits/is_copy_constructible.h" }
-    module is_core_convertible                 { private header "__type_traits/is_core_convertible.h" }
+    module is_core_convertible                 {
+      private header "__type_traits/is_core_convertible.h"
+      export integral_constant
+    }
     module is_default_constructible            { private header "__type_traits/is_default_constructible.h" }
     module is_destructible                     { private header "__type_traits/is_destructible.h" }
     module is_empty                            { private header "__type_traits/is_empty.h" }
     module is_enum                             { private header "__type_traits/is_enum.h" }
     module is_final                            { private header "__type_traits/is_final.h" }
     module is_floating_point                   { private header "__type_traits/is_floating_point.h" }
     module is_function                         { private header "__type_traits/is_function.h" }
     module is_fundamental                      { private header "__type_traits/is_fundamental.h" }
module type_traits {
     module is_trivially_destructible           { private header "__type_traits/is_trivially_destructible.h" }
     module is_trivially_move_assignable        { private header "__type_traits/is_trivially_move_assignable.h" }
     module is_trivially_move_constructible     { private header "__type_traits/is_trivially_move_constructible.h" }
     module is_unbounded_array                  { private header "__type_traits/is_unbounded_array.h" }
     module is_union                            { private header "__type_traits/is_union.h" }
     module is_unsigned                         { private header "__type_traits/is_unsigned.h" }
     module is_unsigned_integer                 { private header "__type_traits/is_unsigned_integer.h" }
     module is_valid_expansion                  { private header "__type_traits/is_valid_expansion.h" }
-    module is_void                             { private header "__type_traits/is_void.h" }
+    module is_void                             {
+      private header "__type_traits/is_void.h"
+      export integral_constant
+    }
     module is_volatile                         { private header "__type_traits/is_volatile.h" }
     module lazy                                { private header "__type_traits/lazy.h" }
     module make_32_64_or_128_bit               { private header "__type_traits/make_32_64_or_128_bit.h" }
     module make_const_lvalue_ref               { private header "__type_traits/make_const_lvalue_ref.h" }
     module make_signed                         { private header "__type_traits/make_signed.h" }
     module make_unsigned                       { private header "__type_traits/make_unsigned.h" }
     module maybe_const                         { private header "__type_traits/maybe_const.h" }
     module nat                                 { private header "__type_traits/nat.h" }

libcxx/include/scoped_allocator

 #include <__config>
 #include <__memory/allocator_traits.h>
 #include <__memory/uses_allocator_construction.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/remove_reference.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <tuple>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/tuple

 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__compare/common_comparison_category.h>
 #include <__compare/synth_three_way.h>
 #include <__config>
+#include <__functional/invoke.h>
 #include <__functional/unwrap_ref.h>
 #include <__fwd/array.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
+#include <__type_traits/apply_cv.h>
+#include <__type_traits/common_reference.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/copy_cvref.h>
+#include <__type_traits/disjunction.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_copy_assignable.h>
+#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_default_constructible.h>
+#include <__type_traits/is_empty.h>
+#include <__type_traits/is_final.h>
+#include <__type_traits/is_implicitly_default_constructible.h>
+#include <__type_traits/is_move_assignable.h>
+#include <__type_traits/is_move_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_nothrow_copy_assignable.h>
+#include <__type_traits/is_nothrow_copy_constructible.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/lazy.h>
 #include <__type_traits/maybe_const.h>
+#include <__type_traits/nat.h>
+#include <__type_traits/negation.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
 #include <__utility/forward.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <cstddef>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [tuple.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 #endif // !defined(_LIBCPP_CXX03_LANG)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <exception>
 #  include <iosfwd>
 #  include <new>
+#  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_TUPLE

libcxx/include/variant

 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__compare/common_comparison_category.h>
 #include <__compare/compare_three_way_result.h>
 #include <__compare/three_way_comparable.h>
 #include <__config>
 #include <__functional/hash.h>
+#include <__functional/invoke.h>
 #include <__functional/operations.h>
 #include <__functional/unary_function.h>
+#include <__type_traits/add_const.h>
+#include <__type_traits/add_cv.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/add_volatile.h>
 #include <__type_traits/dependent_type.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_destructible.h>
+#include <__type_traits/is_nothrow_move_constructible.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/is_void.h>
+#include <__type_traits/remove_const.h>
+#include <__type_traits/type_identity.h>
+#include <__type_traits/void_t.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>
 #include <new>
 #include <tuple>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [variant.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
 #endif
 
 #endif // _LIBCPP_VARIANT

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_concepts.pass.cpp

 //   type, then ITER_CONCEPT(I) denotes that type.
 // (1.2) -- Otherwise, if the qualified-id ITER_TRAITS(I)::iterator_category is
 // valid and names a type, then ITER_CONCEPT(I) denotes that type.
 // (1.3) -- Otherwise, if iterator_traits<I> names a specialization generated
 // from the primary template, then ITER_CONCEPT(I) denotes
 // random_access_iterator_tag.
 // (1.4) -- Otherwise, ITER_CONCEPT(I) does not denote a type.
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-private-header
+
 #include "test_macros.h"
 
+#include <__type_traits/is_valid_expansion.h>
 #include <iterator>
+
 struct OtherTag : std::input_iterator_tag {};
 struct OtherTagTwo : std::output_iterator_tag {};
 
 struct MyIter {
   using iterator_category = std::random_access_iterator_tag;
   using iterator_concept = int;
   using value_type = char;
   using difference_type = std::ptrdiff_t;

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 fstream cstdlib
 fstream cstring
 fstream filesystem
 fstream initializer_list
 fstream istream
 fstream mutex
 fstream ostream
 fstream string
-fstream type_traits
 fstream typeinfo
 fstream version
 functional array
 functional atomic
 functional cstddef
 functional cstdint
 functional cstdlib
 functional cstring

 istream version
 iterator compare
 iterator concepts
 iterator cstddef
 iterator cstdlib
 iterator initializer_list
 iterator iosfwd
 iterator limits
-iterator type_traits
 iterator variant
 iterator version
 latch atomic
 latch limits
 latch version
 limits version
 list compare
 list cstddef

 locale initializer_list
 locale ios
 locale iosfwd
 locale limits
 locale mutex
 locale new
 locale streambuf
 locale string
-locale type_traits
 locale version
 map compare
 map cstddef
 map cstdlib
 map initializer_list
 map limits
 map new
 map optional

 thread new
 thread ratio
 thread system_error
 thread tuple
 thread type_traits
 thread version
 tuple compare
 tuple cstddef
-tuple type_traits
 tuple version
 type_traits cstddef
 type_traits cstdint
 type_traits version
 typeindex compare
 typeindex typeinfo
 typeindex version
 typeinfo cstddef

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

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.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
 
 // template<class In>
 // concept indirectly_readable;
 
-#include <iterator>
-
 #include <concepts>
+#include <iterator>
+#include <type_traits>
 
 #include "read_write.h"
 
 template <class In>
 constexpr bool check_indirectly_readable() {
   constexpr bool result = std::indirectly_readable<In>;
   static_assert(std::indirectly_readable<In const> == result);
   static_assert(std::indirectly_readable<In volatile> == result);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/iter_common_reference_t.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
 
 // iter_common_reference_t
 
-#include <iterator>
-
 #include <concepts>
+#include <iterator>
+#include <type_traits>
 
 struct X { };
 
 // value_type and dereferencing are the same
 struct T1 {
   using value_type = X;
   X operator*() const;
 };

libcxx/test/std/iterators/predef.iterators/iterators.common/ctor.converting.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 I2, class S2>
 //   requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
 //     constexpr common_iterator(const common_iterator<I2, S2>& x);
 
-#include <iterator>
 #include <cassert>
-
-#include "test_macros.h"
+#include <iterator>
+#include <type_traits>
 
 constexpr bool test()
 {
   struct Base {};
   struct Derived : Base {};
 
   using BaseIt = std::common_iterator<Base*, const Base*>;
   using DerivedIt = std::common_iterator<Derived*, const Derived*>;

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/assign.converting.pass.cpp

 // <iterator>
 
 // move_sentinel
 
 // template<class S2>
 //   requires assignable_from<S&, const S2&>
 //     constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
 
-#include <iterator>
 #include <cassert>
 #include <concepts>
+#include <iterator>
+#include <type_traits>
 
 struct NonAssignable {
   NonAssignable& operator=(int i);
 };
 static_assert(std::semiregular<NonAssignable>);
 static_assert(std::is_assignable_v<NonAssignable, int>);
 static_assert(!std::assignable_from<NonAssignable, int>);
 

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/ctor.converting.pass.cpp

 // <iterator>
 
 // move_sentinel
 
 // template<class S2>
 //    requires convertible_to<const S2&, S>
 //      constexpr move_sentinel(const move_sentinel<S2>& s);
 
-#include <iterator>
 #include <cassert>
 #include <concepts>
+#include <iterator>
+#include <type_traits>
 
 struct NonConvertible {
     explicit NonConvertible();
     NonConvertible(int i);
     explicit NonConvertible(long i) = delete;
 };
 static_assert(std::semiregular<NonConvertible>);
 static_assert(std::is_convertible_v<long, NonConvertible>);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/ctor.sentinel.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>
 
 // move_sentinel
 
 // constexpr explicit move_sentinel(S s);
 
-#include <iterator>
 #include <cassert>
+#include <iterator>
+#include <type_traits>
 
 constexpr bool test()
 {
   // The underlying sentinel is an integer.
   {
     static_assert(!std::is_convertible_v<int, std::move_sentinel<int>>);
     std::move_sentinel<int> m(42);
     assert(m.base() == 42);

libcxx/test/std/library/description/conventions/expos.only.func/synth_three_way.pass.cpp

 TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
 TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
 TEST_MSVC_DIAGNOSTIC_IGNORED(4242 4244) // Various truncation warnings
 
 #include <cassert>
 #include <compare>
 #include <limits>  // quiet_NaN
 #include <tuple>
+#include <type_traits>
 #include <utility> // declval
 
 template <typename T, typename U = T>
 concept can_synth_three_way = requires(T t, U u) { std::tuple<T>(t) <=> std::tuple<U>(u); };
 
 template <typename T, typename U>
 constexpr auto synth_three_way(const T& t, const U& u) {
   return std::tuple<T>(t) <=> std::tuple<U>(u);

libcxx/test/std/utilities/tuple/tuple.general/ignore.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
 //
 //===----------------------------------------------------------------------===//
 
 // <tuple>
 
 // constexpr unspecified ignore;
 
 // UNSUPPORTED: c++03
 
-#include <tuple>
 #include <cassert>
+#include <tuple>
+#include <type_traits>
 
 #include "test_macros.h"
 
 constexpr bool test_ignore_constexpr()
 {
 #if TEST_STD_VER > 11
     { // Test that std::ignore provides constexpr converting assignment.
         auto& res = (std::ignore = 42);

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR22806_constrain_tuple_like_ctor.pass.cpp

 
 // template <class... Types> class tuple;
 
 // Check that the tuple-like ctors are properly disabled when the UTypes...
 // constructor should be selected.
 //
 // See https://llvm.org/PR22806.
 
-#include <tuple>
-#include <memory>
 #include <cassert>
+#include <memory>
+#include <tuple>
+#include <type_traits>
 
 #include "test_macros.h"
 
 template <class Tp>
 using uncvref_t = typename std::remove_cv<typename std::remove_reference<Tp>::type>::type;
 
 template <class Tuple, class = uncvref_t<Tuple>>
 struct IsTuple : std::false_type {};

libcxx/test/support/min_allocator.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 MIN_ALLOCATOR_H
 #define MIN_ALLOCATOR_H
 
-#include <cstddef>
-#include <cstdlib>
-#include <cstddef>
 #include <cassert>
 #include <climits>
+#include <cstddef>
+#include <cstdlib>
 #include <iterator>
 #include <memory>
 #include <new>
+#include <type_traits>
 
 #include "test_macros.h"
 
 template <class T>
 class bare_allocator
 {
 public:
     typedef T value_type;