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

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[Mordante]

LGTM, thanks!

[philnik]

Landing this without libc++abi approval, since it's just include fixes.

libcxx/include/__compare/common_comparison_category.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___COMPARE_COMMON_COMPARISON_CATEGORY_H
 #define _LIBCPP___COMPARE_COMMON_COMPARISON_CATEGORY_H
 
 #include <__compare/ordering.h>
 #include <__config>
-#include <type_traits>
+#include <__type_traits/is_same.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17

libcxx/include/__compare/ordering.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___COMPARE_ORDERING_H
 #define _LIBCPP___COMPARE_ORDERING_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_same.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/__compare/three_way_comparable.h

 
 #include <__compare/common_comparison_category.h>
 #include <__compare/ordering.h>
 #include <__concepts/common_reference_with.h>
 #include <__concepts/equality_comparable.h>
 #include <__concepts/same_as.h>
 #include <__concepts/totally_ordered.h>
 #include <__config>
+#include <__type_traits/common_reference.h>
 #include <__type_traits/make_const_lvalue_ref.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/unwrap_ref.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___FUNCTIONAL_UNWRAP_REF_H
 #define _LIBCPP___FUNCTIONAL_UNWRAP_REF_H
 
 #include <__config>
+#include <__type_traits/decay.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>

libcxx/include/__utility/as_const.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___UTILITY_AS_CONST_H
 #define _LIBCPP___UTILITY_AS_CONST_H
 
 #include <__config>
+#include <__type_traits/add_const.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 > 14

libcxx/include/__utility/auto_cast.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___UTILITY_AUTO_CAST_H
 #define _LIBCPP___UTILITY_AUTO_CAST_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/decay.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #define _LIBCPP_AUTO_CAST(expr) static_cast<typename decay<decltype((expr))>::type>(expr)
 
 #endif // _LIBCPP___UTILITY_AUTO_CAST_H

libcxx/include/__utility/cmp.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___UTILITY_CMP_H
 #define _LIBCPP___UTILITY_CMP_H
 
 #include <__config>
+#include <__type_traits/disjunction.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_signed.h>
+#include <__type_traits/make_unsigned.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #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/__utility/exchange.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___UTILITY_EXCHANGE_H
 #define _LIBCPP___UTILITY_EXCHANGE_H
 
 #include <__config>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_move_constructible.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 > 11

libcxx/include/__utility/in_place.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___UTILITY_IN_PLACE_H
 #define _LIBCPP___UTILITY_IN_PLACE_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/remove_cvref.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/__utility/integer_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___UTILITY_INTEGER_SEQUENCE_H
 #define _LIBCPP___UTILITY_INTEGER_SEQUENCE_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/is_integral.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <size_t...> struct __tuple_indices;

libcxx/include/__utility/move.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___UTILITY_MOVE_H
 #define _LIBCPP___UTILITY_MOVE_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>

libcxx/include/__utility/pair.h

 #include <__config>
 #include <__functional/unwrap_ref.h>
 #include <__fwd/get.h>
 #include <__fwd/tuple.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__tuple/tuple_element.h>
 #include <__tuple/tuple_indices.h>
 #include <__tuple/tuple_size.h>
+#include <__type_traits/common_reference.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/conditional.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_default_constructible.h>
 #include <__type_traits/is_implicitly_default_constructible.h>
+#include <__type_traits/is_move_assignable.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_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/nat.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 #include <cstddef>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)

libcxx/include/__utility/rel_ops.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___UTILITY_REL_OPS_H
 #define _LIBCPP___UTILITY_REL_OPS_H
 
 #include <__config>
-#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
 
 namespace rel_ops

libcxx/include/__utility/to_underlying.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___UTILITY_TO_UNDERLYING_H
 #define _LIBCPP___UTILITY_TO_UNDERLYING_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/underlying_type.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG

libcxx/include/limits

 template<> class numeric_limits<cv long double>;
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <type_traits>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_signed.h>
+#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 #include <version>
template <class _Tp>
     _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::tinyness_before;
 template <class _Tp>
     _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const volatile _Tp>::round_style;
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
+#endif
+
 #endif // _LIBCPP_LIMITS

libcxx/include/module.modulemap.in

module type_traits {
     module enable_if                           { private header "__type_traits/enable_if.h" }
     module extent                              { private header "__type_traits/extent.h" }
     module has_unique_object_representation    { private header "__type_traits/has_unique_object_representation.h" }
     module has_virtual_destructor              { private header "__type_traits/has_virtual_destructor.h" }
     module integral_constant                   { private header "__type_traits/integral_constant.h" }
     module is_abstract                         { private header "__type_traits/is_abstract.h" }
     module is_aggregate                        { private header "__type_traits/is_aggregate.h" }
     module is_allocator                        { private header "__type_traits/is_allocator.h" }
-    module is_arithmetic                       { private header "__type_traits/is_arithmetic.h" }
+    module is_arithmetic {
+      private header "__type_traits/is_arithmetic.h"
+      export integral_constant
+    }
     module is_array                            { private header "__type_traits/is_array.h" }
     module is_assignable                       { private header "__type_traits/is_assignable.h" }
     module is_base_of                          { private header "__type_traits/is_base_of.h" }
     module is_bounded_array                    { private header "__type_traits/is_bounded_array.h" }
     module is_callable                         { private header "__type_traits/is_callable.h" }
     module is_char_like_type                   { private header "__type_traits/is_char_like_type.h" }
     module is_class                            { private header "__type_traits/is_class.h" }
     module is_compound                         { private header "__type_traits/is_compound.h" }

libcxx/include/utility

 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/priority_tag.h>
 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
 #include <__utility/to_underlying.h>
 #include <__utility/transaction.h>
 #include <__utility/unreachable.h>
-#include <type_traits>
 #include <version>
 
 // standard-mandated includes
 
 // [utility.syn]
 #include <compare>
 #include <initializer_list>
 
 // [tuple.helper]
 #include <__tuple/tuple_element.h>
 #include <__tuple/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 <iosfwd>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_UTILITY

libcxx/test/libcxx/transitive_includes/cxx03.csv

 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
-memory_resource type_traits
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex functional

libcxx/test/libcxx/transitive_includes/cxx11.csv

 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
-memory_resource type_traits
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex functional

libcxx/test/libcxx/transitive_includes/cxx14.csv

 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
-memory_resource type_traits
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex functional

libcxx/test/libcxx/transitive_includes/cxx17.csv

 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
-memory_resource type_traits
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex functional

libcxx/test/libcxx/transitive_includes/cxx20.csv

 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
-memory_resource type_traits
 memory_resource version
 mutex atomic
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex functional

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 compare version
 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex type_traits
 complex version
 concepts cstddef
-concepts type_traits
 concepts version
 condition_variable atomic
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable initializer_list
 condition_variable iosfwd

 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits
 experimental/functional unordered_map
 experimental/functional vector
 experimental/iterator cstddef
 experimental/iterator iosfwd
 experimental/iterator iterator
-experimental/iterator type_traits
 experimental/list experimental/memory_resource
 experimental/list list
 experimental/map experimental/memory_resource
 experimental/map map
 experimental/memory_resource cstddef
 experimental/memory_resource cstdlib
 experimental/memory_resource experimental/utility
 experimental/memory_resource limits

 iterator iosfwd
 iterator limits
 iterator type_traits
 iterator variant
 iterator version
 latch atomic
 latch limits
 latch version
-limits type_traits
 limits version
 list compare
 list cstddef
 list cstdint
 list cstdlib
 list cstring
 list initializer_list
 list limits

 memory version
 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
-memory_resource type_traits
 memory_resource version
 mutex atomic
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex initializer_list
 mutex iosfwd

 span initializer_list
 span limits
 span type_traits
 span version
 sstream cstddef
 sstream istream
 sstream ostream
 sstream string
-sstream type_traits
 sstream version
 stack compare
 stack cstddef
 stack deque
 stack initializer_list
 stack type_traits
 stack version
 stdexcept cstdlib

 unordered_set tuple
 unordered_set type_traits
 unordered_set version
 utility compare
 utility cstddef
 utility cstdlib
 utility initializer_list
 utility limits
-utility type_traits
 utility version
 valarray cmath
 valarray cstddef
 valarray cstdlib
 valarray cstring
 valarray initializer_list
 valarray limits
 valarray new

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/U_V.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
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // template<class U, class V> pair(U&& x, V&& y);
 
+#include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 
 struct ExplicitT {
     constexpr explicit ExplicitT(int x) : value(x) {}
     int value;

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/const_first_const_second.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
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // pair(const T1& x, const T2& y);
 
+#include <type_traits>
 #include <utility>
 
-#include "test_macros.h"
-
-
 struct ExplicitT {
     constexpr explicit ExplicitT(int x) : value(x) {}
     constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {}
     int value;
 };
 
 struct ImplicitT {
     constexpr ImplicitT(int x) : value(x) {}

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/const_pair_U_V.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
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // template <class U, class V> EXPLICIT constexpr pair(const pair<U, V>& p);
 
+#include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 
 struct ExplicitT {
     constexpr explicit ExplicitT(int x) : value(x) {}
     constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {}

libcxx/test/std/utilities/expected/expected.unexpected/swap/swap.free.pass.cpp

 //
 // Constraints: is_swappable_v<E> is true.
 //
 // Effects: Equivalent to x.swap(y).
 
 #include <cassert>
 #include <concepts>
 #include <expected>
+#include <type_traits>
 #include <utility>
 
 // test noexcept
 struct NoexceptSwap {
   friend void swap(NoexceptSwap&, NoexceptSwap&) noexcept;
 };
 
 struct MayThrowSwap {

libcxx/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp

 // template <class T>
 //   pair<T*, ptrdiff_t>
 //   get_temporary_buffer(ptrdiff_t n);
 //
 // template <class T>
 //   void
 //   return_temporary_buffer(T* p);
 
-#include <memory>
 #include <cassert>
+#include <cstdint>
+#include <memory>
 #include <utility>
 
 #include "test_macros.h"
 
 struct alignas(32) A {
     int field;
 };
 

libcxx/test/std/utilities/utility/as_const/as_const.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
 
 // template <class T> constexpr add_const<T>& as_const(T& t) noexcept;      // C++17
 // template <class T>           add_const<T>& as_const(const T&&) = delete; // C++17
 
-#include <utility>
 #include <cassert>
-
-#include "test_macros.h"
+#include <type_traits>
+#include <utility>
 
 struct S {int i;};
 bool operator==(const S& x, const S& y) { return x.i == y.i; }
 bool operator==(const volatile S& x, const volatile S& y) { return x.i == y.i; }
 
 template<typename T>
 void test(T& t)
 {

libcxx/test/std/utilities/utility/forward/move_if_noexcept.pass.cpp

 //     typename conditional
 //     <
 //         !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
 //         const T&,
 //         T&&
 //     >::type
 //     move_if_noexcept(T& x);
 
+#include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 class A
 {
     A(const A&);
     A& operator=(const A&);

libcxx/test/std/utilities/utility/pairs/pair.astuple/tuple_element.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
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // tuple_element<I, pair<T1, T2> >::type
 
+#include <type_traits>
 #include <utility>
 
-#include "test_macros.h"
-
 template <class T1, class T2>
 void test()
 {
     {
     typedef T1 Exp1;
     typedef T2 Exp2;
     typedef std::pair<T1, T2> P;
     static_assert((std::is_same<typename std::tuple_element<0, P>::type, Exp1>::value), "");

libcxx/test/std/utilities/utility/pairs/pairs.pair/move_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
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // pair(pair&&) = default;
 
-#include <utility>
-#include <memory>
 #include <cassert>
+#include <memory>
+#include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 
 struct Dummy {
   Dummy(Dummy const&) = delete;
   Dummy(Dummy &&) = default;
 };
 

libcxx/test/std/utilities/utility/pairs/pairs.pair/trivial_copy_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
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // pair(pair const&) = default;
 // pair(pair&&) = default;
 
-#include <utility>
 #include <cassert>
+#include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 
 struct Dummy {
   Dummy(Dummy const&) = delete;
   Dummy(Dummy &&) = default;
 };
 

libcxx/test/std/utilities/utility/pairs/pairs.spec/non_member_const_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
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2>
 // void swap(const pair<T1, T2>& x, const pair<T1, T2>& y) const noexcept(noexcept(x.swap(y)));;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
 #include <cassert>
+#include <type_traits>
 #include <utility>
 
 #include "test_macros.h"
 
 // Constraints:
 // For the second overload, is_swappable_v<const T1> is true and is_swappable_v<const T2> is true.
 struct NonConstSwappable {
   friend constexpr void swap(NonConstSwappable&, NonConstSwappable&);

 
 // gcc cannot have mutable member in constant expression
 #if !defined(TEST_COMPILER_GCC)
   static_assert(test());
 #endif
 
   return 0;
 }
 No newline at end of file

libcxx/test/std/utilities/utility/utility.inplace/inplace.pass.cpp

 
 // template <size_t I>
 //   struct in_place_index_t {
 //     explicit in_place_index_t() = default;
 //   };
 // template <size_t I>
 //   inline constexpr in_place_index_t<I> in_place_index{};
 
-#include <utility>
 #include <cassert>
 #include <memory>
-
-#include "test_macros.h"
+#include <type_traits>
+#include <utility>
 
 template <class Tp, class Up>
 constexpr bool check_tag(Up) {
     return std::is_same<Tp, std::decay_t<Tp>>::value
         && std::is_same<Tp, Up>::value;
 }
 
 int main(int, char**) {

libcxxabi/src/cxa_guard_impl.h

 #    include <sys/syscall.h>
 #  endif
 #  if __has_include(<unistd.h>)
 #    include <unistd.h>
 #  endif
 #endif
 
 #include <__threading_support>
+#include <cstdint>
 #include <cstring>
 #include <limits.h>
 #include <stdlib.h>
 
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 #  if defined(__ELF__) && defined(_LIBCXXABI_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")
 #  endif