[libc++] Move __thread_id out of <__threading_support>

[ldionne]

Summary

This makes <__threading_support> closer to handling only the bridge
between the system's implementation of threading and the rest of libc++.

[ldionne]

Fix order of headers in ignore_format.txt

[ldionne]

Add missing includes

[ldionne]

Adjust transitive includes. It turns out that this patch removes a few includes of <iosfwd>. I don't foresee this being an issue so I don't think it is worth trying to add those back for backwards compatibility.

[ldionne]

Fix CI.

[ldionne]

CI failure is a fluke.

libcxx/docs/ReleaseNotes.rst

 
 - ``<algorithm>`` no longer includes ``<chrono>`` in any C++ version (it was previously included in C++17 and earlier).
 
 - ``<string>`` no longer includes ``<vector>`` in any C++ version (it was previously included in C++20 and earlier).
 
 - ``<string>``, ``<string_view>``, and ``<mutex>`` no longer include ``<functional>``
   in any C++ version (it was previously included in C++20 and earlier).
 
+- ``<atomic>``, ``<barrier>``, ``<latch>``, ``<numeric>``, ``<semaphore>`` and ``<shared_mutex>`` no longer include ``<iosfwd>``
+  (it was previously included in all Standard versions).
+
 - The headers ``<experimental/algorithm>`` and ``<experimental/functional>`` have been removed, since all the contents
   have been implemented in namespace ``std`` for at least two releases.
 
 - The formatter specialization ``template<size_t N> struct formatter<const charT[N], charT>``
   has been removed. Since libc++'s format library was marked experimental there
   is no backwards compatibility option. This specialization has been removed
   from the Standard since it was never used, the proper specialization to use
   instead is ``template<size_t N> struct formatter<charT[N], charT>``.

libcxx/include/CMakeLists.txt

set(files
   __support/xlocale/__posix_l_fallback.h
   __support/xlocale/__strtonum_fallback.h
   __system_error/errc.h
   __system_error/error_category.h
   __system_error/error_code.h
   __system_error/error_condition.h
   __system_error/system_error.h
   __thread/formatter.h
+  __thread/id.h
   __thread/poll_with_backoff.h
   __thread/this_thread.h
   __thread/thread.h
   __thread/timed_backoff_policy.h
   __threading_support
   __tree
   __tuple/make_tuple_types.h
   __tuple/pair_like.h

libcxx/include/__condition_variable/condition_variable.h

 #include <__config>
 #include <__mutex/mutex.h>
 #include <__mutex/unique_lock.h>
 #include <__system_error/system_error.h>
 #include <__threading_support>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_floating_point.h>
 #include <__utility/move.h>
+#include <limits>
 #include <ratio>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/__thread/formatter.h

 
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/parser_std_format_spec.h>
-#include <__threading_support>
+#include <__thread/id.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__thread/id.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___THREAD_ID_H
+#define _LIBCPP___THREAD_ID_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <__fwd/hash.h>
+#include <__threading_support>
+#include <iosfwd>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+class _LIBCPP_EXPORTED_FROM_ABI thread;
+class _LIBCPP_EXPORTED_FROM_ABI __thread_id;
+
+namespace this_thread
+{
+
+_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
+
+} // namespace this_thread
+
+template<> struct hash<__thread_id>;
+
+class _LIBCPP_TEMPLATE_VIS __thread_id
+{
+    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
+    // NULL is the no-thread value on Darwin.  Someone needs to check
+    // on other platforms.  We assume 0 works everywhere for now.
+    __libcpp_thread_id __id_;
+
+    static _LIBCPP_HIDE_FROM_ABI
+        bool __lt_impl(__thread_id __x, __thread_id __y) _NOEXCEPT
+        { // id==0 is always less than any other thread_id
+        if (__x.__id_ == 0) return __y.__id_ != 0;
+        if (__y.__id_ == 0) return false;
+        return  __libcpp_thread_id_less(__x.__id_, __y.__id_);
+        }
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    __thread_id() _NOEXCEPT : __id_(0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void __reset() { __id_ = 0; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT;
+#if _LIBCPP_STD_VER <= 17
+    friend _LIBCPP_HIDE_FROM_ABI bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT;
+#else // _LIBCPP_STD_VER <= 17
+    friend _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept;
+#endif // _LIBCPP_STD_VER <= 17
+
+    template<class _CharT, class _Traits>
+    friend
+    _LIBCPP_INLINE_VISIBILITY
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);
+
+private:
+    _LIBCPP_INLINE_VISIBILITY
+    __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
+
+    _LIBCPP_HIDE_FROM_ABI friend __libcpp_thread_id __get_underlying_id(const __thread_id __id) { return __id.__id_; }
+
+    friend __thread_id this_thread::get_id() _NOEXCEPT;
+    friend class _LIBCPP_EXPORTED_FROM_ABI thread;
+    friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
+};
+
+inline _LIBCPP_HIDE_FROM_ABI
+bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT {
+  // Don't pass id==0 to underlying routines
+  if (__x.__id_ == 0)
+    return __y.__id_ == 0;
+  if (__y.__id_ == 0)
+    return false;
+  return __libcpp_thread_id_equal(__x.__id_, __y.__id_);
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI
+bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT {
+  return !(__x == __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI
+bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT {
+  return __thread_id::__lt_impl(__x.__id_, __y.__id_);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__y < __x); }
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(__thread_id __x, __thread_id __y) _NOEXCEPT { return __y < __x; }
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__x < __y); }
+
+#else // _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI
+strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept {
+  if (__x == __y)
+    return strong_ordering::equal;
+  if (__thread_id::__lt_impl(__x, __y))
+    return strong_ordering::less;
+  return strong_ordering::greater;
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
+namespace this_thread
+{
+
+_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
+
+} // namespace this_thread
+
+namespace this_thread
+{
+
+inline _LIBCPP_INLINE_VISIBILITY
+__thread_id
+get_id() _NOEXCEPT
+{
+    return __libcpp_thread_get_current_id();
+}
+
+} // namespace this_thread
+
+#endif // !_LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___THREAD_ID_H

libcxx/include/__thread/thread.h

 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__exception/terminate.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex/mutex.h>
 #include <__system_error/system_error.h>
+#include <__thread/id.h>
 #include <__threading_support>
 #include <__utility/forward.h>
+#include <iosfwd>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__threading_support

 // -*- 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___THREADING_SUPPORT
 #define _LIBCPP___THREADING_SUPPORT
 
 #include <__availability>
 #include <__chrono/convert_to_timespec.h>
 #include <__chrono/duration.h>
-#include <__compare/ordering.h>
 #include <__config>
-#include <__fwd/hash.h>
 #include <__thread/poll_with_backoff.h>
 #include <errno.h>
-#include <iosfwd>
-#include <limits>
 
 #ifdef __MVS__
 # include <__support/ibm/nanosleep.h>
 #endif
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
 #endif

 
 int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
 {
   return tss_set(__key, __p) == thrd_success ? 0 : EINVAL;
 }
 
 #endif
 
-
 #endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL || _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL
 
-class _LIBCPP_EXPORTED_FROM_ABI thread;
-class _LIBCPP_EXPORTED_FROM_ABI __thread_id;
-
-namespace this_thread
-{
-
-_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
-
-} // namespace this_thread
-
-template<> struct hash<__thread_id>;
-
-class _LIBCPP_TEMPLATE_VIS __thread_id
-{
-    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
-    // NULL is the no-thread value on Darwin.  Someone needs to check
-    // on other platforms.  We assume 0 works everywhere for now.
-    __libcpp_thread_id __id_;
-
-    static _LIBCPP_HIDE_FROM_ABI
-        bool __lt_impl(__thread_id __x, __thread_id __y) _NOEXCEPT
-        { // id==0 is always less than any other thread_id
-        if (__x.__id_ == 0) return __y.__id_ != 0;
-        if (__y.__id_ == 0) return false;
-        return  __libcpp_thread_id_less(__x.__id_, __y.__id_);
-        }
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __thread_id() _NOEXCEPT : __id_(0) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __reset() { __id_ = 0; }
-
-    friend _LIBCPP_HIDE_FROM_ABI bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT;
-#if _LIBCPP_STD_VER <= 17
-    friend _LIBCPP_HIDE_FROM_ABI bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT;
-#else // _LIBCPP_STD_VER <= 17
-    friend _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept;
-#endif // _LIBCPP_STD_VER <= 17
-
-    template<class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);
-
-private:
-    _LIBCPP_INLINE_VISIBILITY
-    __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
-
-    _LIBCPP_HIDE_FROM_ABI friend __libcpp_thread_id __get_underlying_id(const __thread_id __id) { return __id.__id_; }
-
-    friend __thread_id this_thread::get_id() _NOEXCEPT;
-    friend class _LIBCPP_EXPORTED_FROM_ABI thread;
-    friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
-};
-
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT {
-  // Don't pass id==0 to underlying routines
-  if (__x.__id_ == 0)
-    return __y.__id_ == 0;
-  if (__y.__id_ == 0)
-    return false;
-  return __libcpp_thread_id_equal(__x.__id_, __y.__id_);
-}
-
-#if _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT {
-  return !(__x == __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT {
-  return __thread_id::__lt_impl(__x.__id_, __y.__id_);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__y < __x); }
-inline _LIBCPP_HIDE_FROM_ABI bool operator>(__thread_id __x, __thread_id __y) _NOEXCEPT { return __y < __x; }
-inline _LIBCPP_HIDE_FROM_ABI bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__x < __y); }
-
-#else // _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_HIDE_FROM_ABI
-strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept {
-  if (__x == __y)
-    return strong_ordering::equal;
-  if (__thread_id::__lt_impl(__x, __y))
-    return strong_ordering::less;
-  return strong_ordering::greater;
-}
-
-#endif // _LIBCPP_STD_VER <= 17
-
-namespace this_thread
-{
-
-inline _LIBCPP_INLINE_VISIBILITY
-__thread_id
-get_id() _NOEXCEPT
-{
-    return __libcpp_thread_get_current_id();
-}
-
-} // namespace this_thread
-
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___THREADING_SUPPORT

libcxx/include/module.modulemap.in

   }
   module thread {
     @requires_LIBCXX_ENABLE_THREADS@
     header "thread"
     export *
 
     module __thread {
       module formatter            { private header "__thread/formatter.h" }
+      module id                   { private header "__thread/id.h" }
       module poll_with_backoff    { private header "__thread/poll_with_backoff.h" }
       module this_thread          { private header "__thread/this_thread.h" }
       module thread               { private header "__thread/thread.h" }
       module timed_backoff_policy { private header "__thread/timed_backoff_policy.h" }
     }
   }
   module tuple {
     header "tuple"

libcxx/include/mutex

 #include <__chrono/time_point.h>
 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/shared_ptr.h>
 #include <__mutex/lock_guard.h>
 #include <__mutex/mutex.h>
 #include <__mutex/tag_types.h>
 #include <__mutex/unique_lock.h>
+#include <__thread/id.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstdint>
+#include <limits>
 #ifndef _LIBCPP_CXX03_LANG
 # include <tuple>
 #endif
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/src/mutex.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__assert>
+#include <__thread/id.h>
 #include <limits>
 #include <mutex>
 
 #include "include/atomic_support.h"
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 #  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")

libcxx/test/libcxx/transitive_includes/cxx03.csv

 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
-atomic iosfwd
 atomic limits
 atomic ratio
 atomic type_traits
 atomic version
 barrier atomic
 barrier concepts
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
-barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
-condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

 iterator utility
 iterator variant
 iterator version
 latch atomic
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
-latch iosfwd
 latch limits
 latch ratio
 latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic

 numeric concepts
 numeric cstddef
 numeric cstdint
 numeric cstring
 numeric ctime
 numeric execution
 numeric functional
 numeric initializer_list
-numeric iosfwd
 numeric iterator
 numeric limits
 numeric new
 numeric ratio
 numeric type_traits
 numeric version
 optional atomic
 optional climits

 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
 semaphore cstdint
 semaphore cstring
 semaphore ctime
-semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set type_traits
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
-shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex stdexcept
 shared_mutex string
 shared_mutex system_error
 shared_mutex type_traits
 shared_mutex version
 source_location cstdint

libcxx/test/libcxx/transitive_includes/cxx11.csv

 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
-atomic iosfwd
 atomic limits
 atomic ratio
 atomic type_traits
 atomic version
 barrier atomic
 barrier concepts
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
-barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
-condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

 iterator utility
 iterator variant
 iterator version
 latch atomic
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
-latch iosfwd
 latch limits
 latch ratio
 latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic

 numeric concepts
 numeric cstddef
 numeric cstdint
 numeric cstring
 numeric ctime
 numeric execution
 numeric functional
 numeric initializer_list
-numeric iosfwd
 numeric iterator
 numeric limits
 numeric new
 numeric ratio
 numeric type_traits
 numeric version
 optional atomic
 optional climits

 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
 semaphore cstdint
 semaphore cstring
 semaphore ctime
-semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set type_traits
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
-shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex stdexcept
 shared_mutex string
 shared_mutex system_error
 shared_mutex type_traits
 shared_mutex version
 source_location cstdint

libcxx/test/libcxx/transitive_includes/cxx14.csv

 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
-atomic iosfwd
 atomic limits
 atomic ratio
 atomic type_traits
 atomic version
 barrier atomic
 barrier concepts
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
-barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
-condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

 iterator utility
 iterator variant
 iterator version
 latch atomic
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
-latch iosfwd
 latch limits
 latch ratio
 latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic

 numeric concepts
 numeric cstddef
 numeric cstdint
 numeric cstring
 numeric ctime
 numeric execution
 numeric functional
 numeric initializer_list
-numeric iosfwd
 numeric iterator
 numeric limits
 numeric new
 numeric ratio
 numeric type_traits
 numeric version
 optional atomic
 optional climits

 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
 semaphore cstdint
 semaphore cstring
 semaphore ctime
-semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set type_traits
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
-shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex stdexcept
 shared_mutex string
 shared_mutex system_error
 shared_mutex type_traits
 shared_mutex version
 source_location cstdint

libcxx/test/libcxx/transitive_includes/cxx17.csv

 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
-atomic iosfwd
 atomic limits
 atomic ratio
 atomic type_traits
 atomic version
 barrier atomic
 barrier concepts
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
-barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
-condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

 iterator utility
 iterator variant
 iterator version
 latch atomic
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
-latch iosfwd
 latch limits
 latch ratio
 latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic

 numeric concepts
 numeric cstddef
 numeric cstdint
 numeric cstring
 numeric ctime
 numeric execution
 numeric functional
 numeric initializer_list
-numeric iosfwd
 numeric iterator
 numeric limits
 numeric new
 numeric ratio
 numeric type_traits
 numeric version
 optional atomic
 optional climits

 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
 semaphore cstdint
 semaphore cstring
 semaphore ctime
-semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set type_traits
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
-shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex stdexcept
 shared_mutex string
 shared_mutex system_error
 shared_mutex type_traits
 shared_mutex version
 source_location cstdint

libcxx/test/libcxx/transitive_includes/cxx20.csv

 array version
 atomic cmath
 atomic compare
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
-atomic iosfwd
 atomic limits
 atomic ratio
 atomic type_traits
 atomic version
 barrier atomic
 barrier concepts
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
-barrier iosfwd
 barrier iterator
 barrier limits
 barrier memory
 barrier new
 barrier ratio
 barrier stdexcept
 barrier type_traits
 barrier variant

 condition_variable cerrno
 condition_variable concepts
 condition_variable cstddef
 condition_variable cstdint
 condition_variable cstdlib
 condition_variable cstring
 condition_variable ctime
 condition_variable initializer_list
-condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
 condition_variable string
 condition_variable system_error
 condition_variable type_traits
 condition_variable typeinfo

 iterator utility
 iterator variant
 iterator version
 latch atomic
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
-latch iosfwd
 latch limits
 latch ratio
 latch type_traits
 latch version
 limits type_traits
 limits version
 list algorithm
 list atomic

 numeric concepts
 numeric cstddef
 numeric cstdint
 numeric cstring
 numeric ctime
 numeric execution
 numeric functional
 numeric initializer_list
-numeric iosfwd
 numeric iterator
 numeric limits
 numeric new
 numeric ratio
 numeric type_traits
 numeric version
 optional atomic
 optional climits

 scoped_allocator type_traits
 scoped_allocator variant
 scoped_allocator version
 semaphore atomic
 semaphore cstddef
 semaphore cstdint
 semaphore cstring
 semaphore ctime
-semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore type_traits
 semaphore version
 set compare
 set concepts
 set cstddef
 set cstdlib
 set functional
 set initializer_list
 set iterator
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set type_traits
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
-shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex stdexcept
 shared_mutex string
 shared_mutex system_error
 shared_mutex type_traits
 shared_mutex version
 source_location cstdint

libcxx/test/libcxx/transitive_includes/cxx23.csv

 array new
 array stdexcept
 array version
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
-atomic iosfwd
 atomic limits
 atomic ratio
 atomic version
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
-barrier iosfwd
 barrier limits
 barrier new
 barrier ratio
 barrier version
 bit cstdint
 bit limits
 bit version
 bitset climits

 iterator iosfwd
 iterator limits
 iterator variant
 iterator version
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
-latch iosfwd
 latch limits
 latch ratio
 latch version
 limits version
 list compare
 list cstddef
 list cstdint
 list cstring

 numeric climits
 numeric cmath
 numeric cstddef
 numeric cstdint
 numeric cstring
 numeric ctime
 numeric execution
 numeric initializer_list
-numeric iosfwd
 numeric limits
 numeric new
 numeric ratio
 numeric version
 optional compare
 optional cstddef
 optional cstdint
 optional cstring

 scoped_allocator limits
 scoped_allocator new
 scoped_allocator tuple
 scoped_allocator version
 semaphore cstddef
 semaphore cstdint
 semaphore cstring
 semaphore ctime
-semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore version
 set compare
 set cstddef
 set cstdint
 set initializer_list
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
-shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex stdexcept
 shared_mutex string
 shared_mutex version
 source_location cstdint
 source_location version
 span array

libcxx/test/libcxx/transitive_includes/cxx26.csv

 array new
 array stdexcept
 array version
 atomic cstddef
 atomic cstdint
 atomic cstdlib
 atomic cstring
 atomic ctime
-atomic iosfwd
 atomic limits
 atomic ratio
 atomic version
 barrier cstddef
 barrier cstdint
 barrier cstring
 barrier ctime
-barrier iosfwd
 barrier limits
 barrier new
 barrier ratio
 barrier version
 bit cstdint
 bit limits
 bit version
 bitset climits

 iterator iosfwd
 iterator limits
 iterator variant
 iterator version
 latch cstddef
 latch cstdint
 latch cstring
 latch ctime
-latch iosfwd
 latch limits
 latch ratio
 latch version
 limits version
 list compare
 list cstddef
 list cstdint
 list cstring

 numeric climits
 numeric cmath
 numeric cstddef
 numeric cstdint
 numeric cstring
 numeric ctime
 numeric execution
 numeric initializer_list
-numeric iosfwd
 numeric limits
 numeric new
 numeric ratio
 numeric version
 optional compare
 optional cstddef
 optional cstdint
 optional cstring

 scoped_allocator limits
 scoped_allocator new
 scoped_allocator tuple
 scoped_allocator version
 semaphore cstddef
 semaphore cstdint
 semaphore cstring
 semaphore ctime
-semaphore iosfwd
 semaphore limits
 semaphore ratio
 semaphore version
 set compare
 set cstddef
 set cstdint
 set initializer_list
 set limits
 set new
 set optional
 set stdexcept
 set tuple
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
-shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
 shared_mutex stdexcept
 shared_mutex string
 shared_mutex version
 source_location cstdint
 source_location version
 span array

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/thread_id.pass.cpp

 // template <class T>
 // struct hash
 // {
 //     size_t operator()(T val) const;
 // };
 
 // Not very portable
 
-#include <thread>
 #include <cassert>
+#include <functional>
+#include <thread>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::thread::id id1;
     std::thread::id id2 = std::this_thread::get_id();
     typedef std::hash<std::thread::id> H;

libcxx/utils/data/ignore_format.txt

 libcxx/include/__support/ibm/nanosleep.h
 libcxx/include/__support/ibm/xlocale.h
 libcxx/include/__support/newlib/xlocale.h
 libcxx/include/__support/win32/locale_win32.h
 libcxx/include/__support/xlocale/__nop_locale_mgmt.h
 libcxx/include/__system_error/errc.h
 libcxx/include/thread
 libcxx/include/__thread/formatter.h
+libcxx/include/__thread/id.h
 libcxx/include/__threading_support
 libcxx/include/__thread/poll_with_backoff.h
 libcxx/include/__thread/this_thread.h
 libcxx/include/__thread/thread.h
 libcxx/include/__thread/timed_backoff_policy.h
 libcxx/include/__tree
 libcxx/include/tuple
 libcxx/include/__tuple/make_tuple_types.h