[libc++] Granularize <type_traits> includes in <bit>, <numbers> and <coroutine>

[philnik]

Summary

<coroutine> seems to be new enough to not be a huge problem.

[Mordante]

LGTM after coroutines is fixed.

libcxx/test/libcxx/transitive_includes/cxx20.csv

186

I really prefer not the breaks existing language versions unless we need to. Even when this header is new, its predecessor in experimental has been around longer. So this might break more than just new users.

[philnik]

libcxx/test/libcxx/transitive_includes/cxx20.csv

186

We also removed includes from <ranges> and <format> because they were still experimental. <coroutine> isn't experimental anymore, but I don't think a lot of people have started using it. We've got it for just two releases now. Also, if people switch over from the experimental version they have to touch the includes anyways.

[philnik]

Don't remove includes in older versions

libcxx/include/__algorithm/sort.h

 }
 
 // Sort the iterator range [__first, __last) using the comparator __comp using
 // the insertion sort algorithm.  Insertion sort has two loops, outer and inner.
 // The implementation below has not bounds check (unguarded) for the inner loop.
 // Assumes that there is an element in the position (__first - 1) and that each
 // element in the input range is greater or equal to the element at __first - 1.
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-void __insertion_sort_unguarded(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+_LIBCPP_HIDE_FROM_ABI void
+__insertion_sort_unguarded(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
   using _Ops = _IterOps<_AlgPolicy>;
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
   if (__first == __last)
     return;
   for (_RandomAccessIterator __i = __first + difference_type(1); __i != __last; ++__i) {
     _RandomAccessIterator __j = __i - difference_type(1);
     if (__comp(*__i, *__j)) {

libcxx/include/__coroutine/coroutine_handle.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___COROUTINE_COROUTINE_HANDLE_H
 #define _LIBCPP___COROUTINE_COROUTINE_HANDLE_H
 
 #include <__assert>
 #include <__config>
 #include <__functional/hash.h>
 #include <__memory/addressof.h>
+#include <__type_traits/remove_cv.h>
 #include <compare>
-#include <type_traits>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__coroutine/coroutine_traits.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___COROUTINE_COROUTINE_TRAITS_H
 #define _LIBCPP___COROUTINE_COROUTINE_TRAITS_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/void_t.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__format/unicode.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_UNICODE_H
 #define _LIBCPP___FORMAT_UNICODE_H
 
 #include <__assert>
 #include <__config>
 #include <__format/extended_grapheme_cluster_table.h>
+#include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>
 #include <bit>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__numeric/gcd_lcm.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___NUMERIC_GCD_LCM_H
 #define _LIBCPP___NUMERIC_GCD_LCM_H
 
 #include <__assert>
 #include <__config>
+#include <__type_traits/common_type.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 <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/__numeric/midpoint.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___NUMERIC_MIDPOINT_H
 #define _LIBCPP___NUMERIC_MIDPOINT_H
 
 #include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_null_pointer.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_void.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/remove_pointer.h>
+#include <cstddef>
 #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/bit

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit/bit_cast.h>
 #include <__bit/byteswap.h>
 #include <__bits> // __libcpp_clz
 #include <__concepts/arithmetic.h>
 #include <__config>
+#include <__type_traits/is_unsigned_integer.h>
 #include <limits>
-#include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

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

libcxx/include/numbers

namespace std::numbers {
   inline constexpr double egamma     = egamma_v<double>;
   inline constexpr double phi        = phi_v<double>;
 }
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__concepts/arithmetic.h>
 #include <__config>
-#include <type_traits>
 #include <version>
 
 #if _LIBCPP_STD_VER > 17
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

 } // namespace numbers
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_NUMBERS

libcxx/include/numeric

 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_numeric>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_NUMERIC

libcxx/test/libcxx/transitive_includes/cxx03.csv

 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine iosfwd
 coroutine limits
-coroutine type_traits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
 deque algorithm
 deque atomic

libcxx/test/libcxx/transitive_includes/cxx11.csv

 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine iosfwd
 coroutine limits
-coroutine type_traits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
 deque algorithm
 deque atomic

libcxx/test/libcxx/transitive_includes/cxx14.csv

 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine iosfwd
 coroutine limits
-coroutine type_traits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
 deque algorithm
 deque atomic

libcxx/test/libcxx/transitive_includes/cxx17.csv

 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine iosfwd
 coroutine limits
-coroutine type_traits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
 deque algorithm
 deque atomic

libcxx/test/libcxx/transitive_includes/cxx20.csv

 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine iosfwd
 coroutine limits
-coroutine type_traits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
 deque algorithm
 deque atomic

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 barrier iosfwd
 barrier limits
 barrier new
 barrier ratio
 barrier type_traits
 bit cstdint
 bit cstdlib
 bit limits
-bit type_traits
 bit version
 bitset climits
 bitset cstddef
 bitset cstdint
 bitset cstdlib
 bitset cstring
 bitset initializer_list
 bitset iosfwd

 condition_variable system_error
 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine limits
-coroutine type_traits
 coroutine version
 cstddef version
 ctgmath ccomplex
 ctgmath cmath
 cwchar cwctype
 cwctype cctype
 deque compare
 deque cstddef

 mutex system_error
 mutex tuple
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
 new exception
 new version
-numbers type_traits
 numbers version
 numeric cmath
 numeric cstddef
 numeric limits
-numeric type_traits
 numeric version
 optional compare
 optional cstddef
 optional cstdint
 optional cstring
 optional initializer_list
 optional limits
 optional new

libcxx/test/std/numerics/bit/bit.endian/endian.pass.cpp

 
 // enum class endian;
 // <bit>
 
 #include <bit>
 #include <cstring>
 #include <cassert>
 #include <cstdint>
+#include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**) {
     static_assert(std::is_enum<std::endian>::value, "");
 
 // Check that E is a scoped enum by checking for conversions.
     typedef std::underlying_type<std::endian>::type UT;

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp

 
 // template <class T>
 //   constexpr T bit_ceil(T x) noexcept;
 
 // Remarks: This function shall not participate in overload resolution unless
 //          T is an unsigned integer type
 
 #include <bit>
+#include <cassert>
+#include <cstddef>
 #include <cstdint>
 #include <limits>
-#include <cassert>
-
-#include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool toobig()
 {