[libc++] Granularize system_error.

[philnik]

LGTM % nit with green CI.

libcxx/include/module.modulemap.in

1439–1444

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Thanks for the review.

libcxx/docs/ReleaseNotes.rst

 - The ``<experimental/coroutine>`` header has been removed in this release. The ``<coroutine>`` header
   has been shipping since LLVM 14, so the Coroutines TS implementation is being removed per our policy
   for removing TSes.
 
 - Several incidental transitive includes have been removed from libc++. Those
   includes are removed based on the language version used. Incidental transitive
   inclusions of the following headers have been removed:
 
-  - C++2b: ``atomic``, ``bit``, ``cstdint``, ``cstdlib``, ``cstring``, ``initializer_list``, ``new``, ``stdexcept``,
-           ``type_traits``, ``typeinfo``
+  - C++2b: ``atomic``, ``bit``, ``cstdint``, ``cstdlib``, ``cstring``, ``initializer_list``, ``limits``, ``new``,
+           ``stdexcept``, ``system_error``, ``type_traits``, ``typeinfo``
 
 - 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

libcxx/include/CMakeLists.txt

set(files
   __support/openbsd/xlocale.h
   __support/solaris/floatingpoint.h
   __support/solaris/wchar.h
   __support/solaris/xlocale.h
   __support/win32/locale_win32.h
   __support/xlocale/__nop_locale_mgmt.h
   __support/xlocale/__posix_l_fallback.h
   __support/xlocale/__strtonum_fallback.h
+  __system_error/error_category.h
+  __system_error/error_code.h
+  __system_error/error_condition.h
+  __system_error/system_error.h
   __thread/poll_with_backoff.h
   __thread/timed_backoff_policy.h
   __threading_support
   __tree
   __tuple_dir/apply_cv.h
   __tuple_dir/make_tuple_types.h
   __tuple_dir/pair_like.h
   __tuple_dir/sfinae_helpers.h

libcxx/include/__condition_variable/condition_variable.h

 #define _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
 
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.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 <ratio>
-#include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__filesystem/directory_entry.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___FILESYSTEM_DIRECTORY_ENTRY_H
 #define _LIBCPP___FILESYSTEM_DIRECTORY_ENTRY_H
 
 #include <__availability>
 #include <__chrono/time_point.h>
+#include <__compare/ordering.h>
 #include <__config>
 #include <__errc>
 #include <__filesystem/file_status.h>
 #include <__filesystem/file_time_type.h>
 #include <__filesystem/file_type.h>
 #include <__filesystem/filesystem_error.h>
 #include <__filesystem/operations.h>
 #include <__filesystem/path.h>
 #include <__filesystem/perms.h>
+#include <__system_error/error_code.h>
+#include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstdint>
 #include <cstdlib>
 #include <iosfwd>
-#include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__filesystem/directory_iterator.h

 #include <__config>
 #include <__filesystem/directory_entry.h>
 #include <__filesystem/directory_options.h>
 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
+#include <__system_error/error_code.h>
+#include <__utility/move.h>
 #include <cstddef>
-#include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM

libcxx/include/__filesystem/filesystem_error.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___FILESYSTEM_FILESYSTEM_ERROR_H
 #define _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
 
 #include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <__memory/shared_ptr.h>
+#include <__system_error/error_code.h>
+#include <__system_error/system_error.h>
 #include <__utility/forward.h>
 #include <__verbose_abort>
 #include <iosfwd>
 #include <new>
-#include <system_error>
+#include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM

libcxx/include/__filesystem/operations.h

 #include <__filesystem/copy_options.h>
 #include <__filesystem/file_status.h>
 #include <__filesystem/file_time_type.h>
 #include <__filesystem/file_type.h>
 #include <__filesystem/path.h>
 #include <__filesystem/perm_options.h>
 #include <__filesystem/perms.h>
 #include <__filesystem/space_info.h>
+#include <__system_error/error_code.h>
 #include <cstdint>
-#include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM

libcxx/include/__filesystem/recursive_directory_iterator.h

 #include <__config>
 #include <__filesystem/directory_entry.h>
 #include <__filesystem/directory_options.h>
 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
+#include <__system_error/error_code.h>
+#include <__utility/move.h>
 #include <cstddef>
-#include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM

libcxx/include/__mutex/unique_lock.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___MUTEX_UNIQUE_LOCK_H
 #define _LIBCPP___MUTEX_UNIQUE_LOCK_H
 
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__memory/addressof.h>
 #include <__mutex/tag_types.h>
+#include <__system_error/system_error.h>
 #include <__utility/swap.h>
-#include <system_error>
+#include <cerrno>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__system_error/error_category.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___SYSTEM_ERROR_ERROR_CATEGORY_H
+#define _LIBCPP___SYSTEM_ERROR_ERROR_CATEGORY_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TYPE_VIS error_condition;
+class _LIBCPP_TYPE_VIS error_code;
+
+class _LIBCPP_HIDDEN __do_message;
+
+class _LIBCPP_TYPE_VIS error_category
+{
+public:
+    virtual ~error_category() _NOEXCEPT;
+
+#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
+    error_category() noexcept;
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
+#endif
+    error_category(const error_category&) = delete;
+    error_category& operator=(const error_category&) = delete;
+
+    virtual const char* name() const _NOEXCEPT = 0;
+    virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
+    virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
+    virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
+    virtual string message(int __ev) const = 0;
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
+
+#if _LIBCPP_STD_VER >= 20
+
+    _LIBCPP_HIDE_FROM_ABI
+    strong_ordering operator<=>(const error_category& __rhs) const noexcept {return compare_three_way()(this, std::addressof(__rhs));}
+
+#else // _LIBCPP_STD_VER >= 20
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
+
+#endif // _LIBCPP_STD_VER >= 20
+
+    friend class _LIBCPP_HIDDEN __do_message;
+};
+
+class _LIBCPP_HIDDEN __do_message
+    : public error_category
+{
+public:
+    string message(int __ev) const override;
+};
+
+_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
+_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CATEGORY_H

libcxx/include/__system_error/error_code.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___SYSTEM_ERROR_ERROR_CODE_H
+#define _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <__errc>
+#include <__functional/hash.h>
+#include <__functional/unary_function.h>
+#include <__system_error/error_category.h>
+#include <__system_error/error_condition.h>
+#include <cstddef>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
+    : public false_type {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
+#endif
+
+namespace __adl_only {
+    // Those cause ADL to trigger but they are not viable candidates,
+    // so they are never actually selected.
+    void make_error_code() = delete;
+} // namespace __adl_only
+
+class _LIBCPP_TYPE_VIS error_code
+{
+    int __val_;
+    const error_category* __cat_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    error_code(int __val, const error_category& __cat) _NOEXCEPT
+        : __val_(__val), __cat_(&__cat) {}
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        error_code(_Ep __e,
+                   typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr
+                                                                     ) _NOEXCEPT
+            {
+                using __adl_only::make_error_code;
+                *this = make_error_code(__e);
+            }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    {
+        __val_ = __val;
+        __cat_ = &__cat;
+    }
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        typename enable_if
+        <
+            is_error_code_enum<_Ep>::value,
+            error_code&
+        >::type
+        operator=(_Ep __e) _NOEXCEPT
+            {
+                using __adl_only::make_error_code;
+                *this = make_error_code(__e);
+                return *this;
+            }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT
+    {
+        __val_ = 0;
+        __cat_ = &system_category();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int value() const _NOEXCEPT {return __val_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    const error_category& category() const _NOEXCEPT {return *__cat_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    error_condition default_error_condition() const _NOEXCEPT
+        {return __cat_->default_error_condition(__val_);}
+
+    string message() const;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+error_code
+make_error_code(errc __e) _NOEXCEPT
+{
+    return error_code(static_cast<int>(__e), generic_category());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
+{
+    return __x.category() == __y.category() && __x.value() == __y.value();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
+{
+    return __x.category().equivalent(__x.value(), __y)
+        || __y.category().equivalent(__x, __y.value());
+}
+
+#if _LIBCPP_STD_VER <= 17
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
+{
+    return __y == __x;
+}
+#endif
+
+#if _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
+{
+    return __x.category() < __y.category()
+        || (__x.category() == __y.category() && __x.value() < __y.value());
+}
+
+#else // _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI strong_ordering
+operator<=>(const error_code& __x, const error_code& __y) noexcept
+{
+    if (auto __c = __x.category() <=> __y.category(); __c != 0)
+        return __c;
+    return __x.value() <=> __y.value();
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<error_code>
+    : public __unary_function<error_code, size_t>
+{
+    _LIBCPP_INLINE_VISIBILITY
+    size_t operator()(const error_code& __ec) const _NOEXCEPT
+    {
+        return static_cast<size_t>(__ec.value());
+    }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H

libcxx/include/__system_error/error_condition.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___SYSTEM_ERROR_ERROR_CONDITION_H
+#define _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <__errc>
+#include <__functional/unary_function.h>
+#include <__system_error/error_category.h>
+#include <cstddef>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
+    : public false_type {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
+#endif
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
+    : true_type { };
+
+#ifdef _LIBCPP_CXX03_LANG
+template <>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
+    : true_type { };
+#endif
+
+namespace __adl_only {
+    // Those cause ADL to trigger but they are not viable candidates,
+    // so they are never actually selected.
+    void make_error_condition() = delete;
+} // namespace __adl_only
+
+class _LIBCPP_TYPE_VIS error_condition
+{
+    int __val_;
+    const error_category* __cat_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    error_condition(int __val, const error_category& __cat) _NOEXCEPT
+        : __val_(__val), __cat_(&__cat) {}
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        error_condition(_Ep __e,
+              typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr
+                                                                     ) _NOEXCEPT
+            {
+                using __adl_only::make_error_condition;
+                *this = make_error_condition(__e);
+            }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    {
+        __val_ = __val;
+        __cat_ = &__cat;
+    }
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        typename enable_if
+        <
+            is_error_condition_enum<_Ep>::value,
+            error_condition&
+        >::type
+        operator=(_Ep __e) _NOEXCEPT
+            {
+                using __adl_only::make_error_condition;
+                *this = make_error_condition(__e);
+                return *this;
+            }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT
+    {
+        __val_ = 0;
+        __cat_ = &generic_category();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int value() const _NOEXCEPT {return __val_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    const error_category& category() const _NOEXCEPT {return *__cat_;}
+    string message() const;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+error_condition
+make_error_condition(errc __e) _NOEXCEPT
+{
+    return error_condition(static_cast<int>(__e), generic_category());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{
+    return __x.category() == __y.category() && __x.value() == __y.value();
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{
+    return __x.category() < __y.category()
+        || (__x.category() == __y.category() && __x.value() < __y.value());
+}
+
+
+#else // _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI strong_ordering
+operator<=>(const error_condition& __x, const error_condition& __y) noexcept
+{
+    if (auto __c = __x.category() <=> __y.category(); __c != 0)
+       return __c;
+    return __x.value() <=> __y.value();
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
+    : public __unary_function<error_condition, size_t>
+{
+    _LIBCPP_INLINE_VISIBILITY
+    size_t operator()(const error_condition& __ec) const _NOEXCEPT
+    {
+        return static_cast<size_t>(__ec.value());
+    }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H

libcxx/include/__system_error/system_error.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___SYSTEM_ERROR_SYSTEM_ERROR_H
+#define _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H
+
+#include <__config>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <stdexcept>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TYPE_VIS system_error
+    : public runtime_error
+{
+    error_code __ec_;
+public:
+    system_error(error_code __ec, const string& __what_arg);
+    system_error(error_code __ec, const char* __what_arg);
+    system_error(error_code __ec);
+    system_error(int __ev, const error_category& __ecat, const string& __what_arg);
+    system_error(int __ev, const error_category& __ecat, const char* __what_arg);
+    system_error(int __ev, const error_category& __ecat);
+    system_error(const system_error&) _NOEXCEPT = default;
+    ~system_error() _NOEXCEPT override;
+
+    _LIBCPP_INLINE_VISIBILITY
+    const error_code& code() const _NOEXCEPT {return __ec_;}
+
+private:
+    static string __init(const error_code&, string);
+};
+
+_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
+void __throw_system_error(int __ev, const char* __what_arg);
+
+
+_LIBCPP_END_NAMESPACE_STD
+#endif // _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H

libcxx/include/condition_variable

 #  include <atomic>
 #  include <concepts>
 #  include <cstdint>
 #  include <cstdlib>
 #  include <cstring>
 #  include <initializer_list>
 #  include <new>
 #  include <stdexcept>
+#  include <system_error>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_CONDITION_VARIABLE

libcxx/include/filesystem

 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <system_error>
 #endif
 
 #endif // _LIBCPP_FILESYSTEM

libcxx/include/future

 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__exception/exception_ptr.h>
+#include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_destructor.h>
+#include <__memory/allocator_traits.h>
+#include <__memory/compressed_pair.h>
+#include <__memory/pointer_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <__system_error/error_condition.h>
 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/alignment_of.h>
 #include <__type_traits/strip_signature.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <mutex>
 #include <new>
-#include <system_error>
+#include <stdexcept>
 #include <thread>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS

 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <exception>
+#  include <system_error>
 #endif
 
 #endif // _LIBCPP_FUTURE

libcxx/include/ios

 
 #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   error "The iostreams library is not supported since libc++ has been configured without support for localization."
 #endif
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__ios/fpos.h>
 #include <__locale>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <__system_error/error_condition.h>
+#include <__system_error/system_error.h>
 #include <__utility/swap.h>
 #include <__verbose_abort>
-#include <system_error>
 #include <version>
 
 // standard-mandated includes
 
 // [ios.syn]
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)

 #  include <concepts>
 #  include <cstddef>
 #  include <cstdlib>
 #  include <cstring>
 #  include <initializer_list>
 #  include <limits>
 #  include <new>
 #  include <stdexcept>
+#  include <system_error>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_IOS

libcxx/include/libcxx.imp

[
   { include: [ "@<__memory/.*>", "private", "<memory>", "public" ] },
   { include: [ "@<__memory_resource/.*>", "private", "<memory_resource>", "public" ] },
   { include: [ "@<__mutex/.*>", "private", "<mutex>", "public" ] },
   { include: [ "@<__numeric/.*>", "private", "<numeric>", "public" ] },
   { include: [ "@<__random/.*>", "private", "<random>", "public" ] },
   { include: [ "@<__ranges/.*>", "private", "<ranges>", "public" ] },
   { include: [ "@<__string/.*>", "private", "<string>", "public" ] },
   { include: [ "@<__support/.*>", "private", "<support>", "public" ] },
+  { include: [ "@<__system_error/.*>", "private", "<system_error>", "public" ] },
   { include: [ "@<__thread/.*>", "private", "<thread>", "public" ] },
   { include: [ "@<__tuple_dir/.*>", "private", "<tuple>", "public" ] },
   { include: [ "@<__type_traits/.*>", "private", "<type_traits>", "public" ] },
   { include: [ "@<__utility/.*>", "private", "<utility>", "public" ] },
   { include: [ "@<__variant/.*>", "private", "<variant>", "public" ] },
 ]

libcxx/include/module.modulemap.in

module __format {
       module extended_grapheme_cluster_table { private header "__format/extended_grapheme_cluster_table.h" }
       module format_arg                      { private header "__format/format_arg.h" }
       module format_arg_store                { private header "__format/format_arg_store.h" }
       module format_args                     { private header "__format/format_args.h" }
       module format_context {
         private header "__format/format_context.h"
         export optional
         export locale
+        export __locale
       }
       module format_error                    { private header "__format/format_error.h" }
       module format_functions                {
         private header "__format/format_functions.h"
         export string
       }
       module format_fwd                      { private header "__format/format_fwd.h" }
       module format_parse_context            { private header "__format/format_parse_context.h" }

   }
   module strstream {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "strstream"
     export *
   }
   module system_error {
     header "system_error"
+    export __errc
     export *
+    module __system_error {
+      module error_category  { private header "__system_error/error_category.h" }
+      module error_code {
+        private header "__system_error/error_code.h"
+        export functional.__functional.hash
+        export functional.__functional.unary_function
+      }
+      module error_condition {
+        private header "__system_error/error_condition.h"
+        export functional.__functional.hash
+        export functional.__functional.unary_function
+      }
+      module system_error { private header "__system_error/system_error.h" }
+    }
   }
   module thread {
     @requires_LIBCXX_ENABLE_THREADS@
     header "thread"
     export *
 
     module __thread {
       module poll_with_backoff    { private header "__thread/poll_with_backoff.h" }

libcxx/include/mutex

 #  include <concepts>
 #  include <cstdlib>
 #  include <cstring>
 #  include <ctime>
 #  include <functional>
 #  include <initializer_list>
 #  include <new>
 #  include <stdexcept>
+#  include <system_error>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
 
 #endif // _LIBCPP_MUTEX

libcxx/include/ostream

 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__exception/operations.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
+#include <__system_error/error_code.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_base_of.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <bitset>
 #include <ios>
 #include <locale>

libcxx/include/shared_mutex

 #include <__chrono/steady_clock.h>
 #include <__chrono/time_point.h>
 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/addressof.h>
 #include <__mutex/mutex.h>
 #include <__mutex/tag_types.h>
 #include <__mutex/unique_lock.h>
+#include <__system_error/system_error.h>
 #include <__utility/swap.h>
 #include <cerrno>
-#include <system_error>
 #include <version>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 #if _LIBCPP_STD_VER >= 14 || defined(_LIBCPP_BUILDING_LIBRARY)
 
swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT
     {__x.swap(__y);}
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <system_error>
+#endif
+
 #endif // _LIBCPP_SHARED_MUTEX

libcxx/include/system_error

 template <> struct hash<std::error_condition>;
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__errc>
-#include <__functional/hash.h>
-#include <__functional/unary_function.h>
-#include <__memory/addressof.h>
-#include <stdexcept>
-#include <string>
+#include <__system_error/error_category.h>
+#include <__system_error/error_code.h>
+#include <__system_error/error_condition.h>
+#include <__system_error/system_error.h>
 #include <version>
 
 // standard-mandated includes
 
 // [system.error.syn]
 #include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// is_error_code_enum
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
-    : public false_type {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
-#endif
-
-// is_error_condition_enum
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
-    : public false_type {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
-#endif
-
-template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
-    : true_type { };
-
-#ifdef _LIBCPP_CXX03_LANG
-template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
-    : true_type { };
-#endif
-
-class _LIBCPP_TYPE_VIS error_condition;
-class _LIBCPP_TYPE_VIS error_code;
-
-// class error_category
-
-class _LIBCPP_HIDDEN __do_message;
-
-class _LIBCPP_TYPE_VIS error_category
-{
-public:
-    virtual ~error_category() _NOEXCEPT;
-
-#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
-    error_category() noexcept;
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
-#endif
-    error_category(const error_category&) = delete;
-    error_category& operator=(const error_category&) = delete;
-
-    virtual const char* name() const _NOEXCEPT = 0;
-    virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
-    virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
-    virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
-    virtual string message(int __ev) const = 0;
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
-
-#if _LIBCPP_STD_VER >= 20
-
-    _LIBCPP_HIDE_FROM_ABI
-    strong_ordering operator<=>(const error_category& __rhs) const noexcept {return compare_three_way()(this, std::addressof(__rhs));}
-
-#else // _LIBCPP_STD_VER >= 20
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
-
-#endif // _LIBCPP_STD_VER >= 20
-
-    friend class _LIBCPP_HIDDEN __do_message;
-};
-
-class _LIBCPP_HIDDEN __do_message
-    : public error_category
-{
-public:
-    string message(int __ev) const override;
-};
-
-_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
-_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
-
-namespace __adl_only {
-    // Those cause ADL to trigger but they are not viable candidates,
-    // so they are never actually selected.
-    void make_error_condition() = delete;
-    void make_error_code() = delete;
-} // namespace __adl_only
-
-class _LIBCPP_TYPE_VIS error_condition
-{
-    int __val_;
-    const error_category* __cat_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    error_condition(int __val, const error_category& __cat) _NOEXCEPT
-        : __val_(__val), __cat_(&__cat) {}
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        error_condition(_Ep __e,
-              typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr
-                                                                     ) _NOEXCEPT
-            {
-                using __adl_only::make_error_condition;
-                *this = make_error_condition(__e);
-            }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void assign(int __val, const error_category& __cat) _NOEXCEPT
-    {
-        __val_ = __val;
-        __cat_ = &__cat;
-    }
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            is_error_condition_enum<_Ep>::value,
-            error_condition&
-        >::type
-        operator=(_Ep __e) _NOEXCEPT
-            {
-                using __adl_only::make_error_condition;
-                *this = make_error_condition(__e);
-                return *this;
-            }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT
-    {
-        __val_ = 0;
-        __cat_ = &generic_category();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    int value() const _NOEXCEPT {return __val_;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
-    string message() const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
-};
-
-inline _LIBCPP_INLINE_VISIBILITY
-error_condition
-make_error_condition(errc __e) _NOEXCEPT
-{
-    return error_condition(static_cast<int>(__e), generic_category());
-}
-
-// error_code
-
-class _LIBCPP_TYPE_VIS error_code
-{
-    int __val_;
-    const error_category* __cat_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    error_code(int __val, const error_category& __cat) _NOEXCEPT
-        : __val_(__val), __cat_(&__cat) {}
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        error_code(_Ep __e,
-                   typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr
-                                                                     ) _NOEXCEPT
-            {
-                using __adl_only::make_error_code;
-                *this = make_error_code(__e);
-            }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void assign(int __val, const error_category& __cat) _NOEXCEPT
-    {
-        __val_ = __val;
-        __cat_ = &__cat;
-    }
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            is_error_code_enum<_Ep>::value,
-            error_code&
-        >::type
-        operator=(_Ep __e) _NOEXCEPT
-            {
-                using __adl_only::make_error_code;
-                *this = make_error_code(__e);
-                return *this;
-            }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT
-    {
-        __val_ = 0;
-        __cat_ = &system_category();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    int value() const _NOEXCEPT {return __val_;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    error_condition default_error_condition() const _NOEXCEPT
-        {return __cat_->default_error_condition(__val_);}
-
-    string message() const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
-};
-
-inline _LIBCPP_INLINE_VISIBILITY
-error_code
-make_error_code(errc __e) _NOEXCEPT
-{
-    return error_code(static_cast<int>(__e), generic_category());
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
-{
-    return __x.category() == __y.category() && __x.value() == __y.value();
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
-{
-    return __x.category().equivalent(__x.value(), __y)
-        || __y.category().equivalent(__x, __y.value());
-}
-
-#if _LIBCPP_STD_VER <= 17
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
-{
-    return __y == __x;
-}
-#endif
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{
-    return __x.category() == __y.category() && __x.value() == __y.value();
-}
-
-#if _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{
-    return __x.category() < __y.category()
-        || (__x.category() == __y.category() && __x.value() < __y.value());
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
-{
-    return __x.category() < __y.category()
-        || (__x.category() == __y.category() && __x.value() < __y.value());
-}
-
-#else // _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_HIDE_FROM_ABI strong_ordering
-operator<=>(const error_code& __x, const error_code& __y) noexcept
-{
-    if (auto __c = __x.category() <=> __y.category(); __c != 0)
-        return __c;
-    return __x.value() <=> __y.value();
-}
-
-inline _LIBCPP_HIDE_FROM_ABI strong_ordering
-operator<=>(const error_condition& __x, const error_condition& __y) noexcept
-{
-    if (auto __c = __x.category() <=> __y.category(); __c != 0)
-       return __c;
-    return __x.value() <=> __y.value();
-}
-
-#endif // _LIBCPP_STD_VER <= 17
-
-template <>
-struct _LIBCPP_TEMPLATE_VIS hash<error_code>
-    : public __unary_function<error_code, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const error_code& __ec) const _NOEXCEPT
-    {
-        return static_cast<size_t>(__ec.value());
-    }
-};
-
-template <>
-struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
-    : public __unary_function<error_condition, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const error_condition& __ec) const _NOEXCEPT
-    {
-        return static_cast<size_t>(__ec.value());
-    }
-};
-
-// system_error
-
-class _LIBCPP_TYPE_VIS system_error
-    : public runtime_error
-{
-    error_code __ec_;
-public:
-    system_error(error_code __ec, const string& __what_arg);
-    system_error(error_code __ec, const char* __what_arg);
-    system_error(error_code __ec);
-    system_error(int __ev, const error_category& __ecat, const string& __what_arg);
-    system_error(int __ev, const error_category& __ecat, const char* __what_arg);
-    system_error(int __ev, const error_category& __ecat);
-    system_error(const system_error&) _NOEXCEPT = default;
-    ~system_error() _NOEXCEPT override;
-
-    _LIBCPP_INLINE_VISIBILITY
-    const error_code& code() const _NOEXCEPT {return __ec_;}
-
-private:
-    static string __init(const error_code&, string);
-};
-
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
-void __throw_system_error(int __ev, const char* __what_arg);
-
-_LIBCPP_END_NAMESPACE_STD
-
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstdint>
+#  include <cstring>
+#  include <limits>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_SYSTEM_ERROR

libcxx/include/thread

 #include <__config>
 #include <__exception/terminate.h>
 #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 <__functional/hash.h>
+#include <__functional/unary_function.h>
 #include <__memory/addressof.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex/mutex.h>
 #include <__mutex/unique_lock.h>
+#include <__system_error/system_error.h>
 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstddef>
+#include <cstdint>
 #include <iosfwd>
-#include <system_error>
 #include <tuple>
 #include <version>
 
 // standard-mandated includes
 
 // [thread.syn]
 #include <compare>
 

 #  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstdint>
 #  include <cstring>
 #  include <functional>
 #  include <new>
+#  include <system_error>
 #endif
 
 #endif // _LIBCPP_THREAD

libcxx/src/chrono.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
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__MVS__)
 // As part of monotonic clock support on z/OS we need macro _LARGE_TIME_API
 // to be defined before any system header to include definition of struct timespec64.
 #define _LARGE_TIME_API
 #endif
 
-#include <cerrno>        // errno
+#include <__system_error/system_error.h>
+#include <cerrno> // errno
 #include <chrono>
-#include <system_error>  // __throw_system_error
 
 #if defined(__MVS__)
 #include <__support/ibm/gettod_zos.h> // gettimeofdayMonotonic
 #endif
 
 #include <time.h>        // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW}
 #include "include/apple_availability.h"
 

libcxx/src/condition_variable.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 <__config>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 #include <condition_variable>
 #include <thread>
-#include <system_error>
 
 #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #  pragma comment(lib, "pthread")
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/src/filesystem/filesystem_common.h

 #include <__config>
 #include <array>
 #include <chrono>
 #include <climits>
 #include <cstdarg>
 #include <ctime>
 #include <filesystem>
 #include <ratio>
-#include <system_error>
 #include <utility>
+#include <system_error>
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 #else
 # include <dirent.h>   // for DIR & friends
 # include <fcntl.h>    /* values for fchmodat */

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 <limits>
 #include <mutex>
-#include <system_error>
 
 #include "include/atomic_support.h"
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 #  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")
 #  endif
 #endif

libcxx/src/random.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 <__config>
 
 #if defined(_LIBCPP_USING_WIN32_RANDOM)
     // Must be defined before including stdlib.h to enable rand_s().
 #   define _CRT_RAND_S
 #endif // defined(_LIBCPP_USING_WIN32_RANDOM)
 
+#include <__system_error/system_error.h>
 #include <limits>
 #include <random>
-#include <system_error>
 
 #if defined(__sun__)
 #   define rename solaris_headers_are_broken
 #endif // defined(__sun__)
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>

libcxx/src/ryu/d2fixed.cpp

 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
 #include <__assert>
 #include <__config>
 #include <charconv>
 #include <cstring>
-#include <system_error>
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2fixed_full_table.h"
 #include "include/ryu/d2s.h"
 #include "include/ryu/d2s_intrinsics.h"
 #include "include/ryu/digit_table.h"
 

libcxx/src/stdexcept.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 <new>
 #include <stdexcept>
 #include <string>
-#include <system_error>
 
 #ifdef _LIBCPP_ABI_VCRUNTIME
 #include "support/runtime/stdexcept_vcruntime.ipp"
 #else
 #include "support/runtime/stdexcept_default.ipp"
 #endif

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
 #include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
 #include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
 #include <__std_stream> // expected-error@*:* {{use of private header from outside its module: '__std_stream'}}
 #include <__string/char_traits.h> // expected-error@*:* {{use of private header from outside its module: '__string/char_traits.h'}}
 #include <__string/constexpr_c_functions.h> // expected-error@*:* {{use of private header from outside its module: '__string/constexpr_c_functions.h'}}
 #include <__string/extern_template_lists.h> // expected-error@*:* {{use of private header from outside its module: '__string/extern_template_lists.h'}}
+#include <__system_error/error_category.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_category.h'}}
+#include <__system_error/error_code.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_code.h'}}
+#include <__system_error/error_condition.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_condition.h'}}
+#include <__system_error/system_error.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/system_error.h'}}
 #include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
 #include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
 #include <__tuple_dir/apply_cv.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/apply_cv.h'}}
 #include <__tuple_dir/make_tuple_types.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/make_tuple_types.h'}}
 #include <__tuple_dir/pair_like.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/pair_like.h'}}
 #include <__tuple_dir/sfinae_helpers.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/sfinae_helpers.h'}}
 #include <__tuple_dir/tuple_element.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/tuple_element.h'}}
 #include <__tuple_dir/tuple_indices.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/tuple_indices.h'}}

libcxx/test/libcxx/transitive_includes/cxx03.csv

 complex sstream
 complex stdexcept
 complex type_traits
 complex version
 concepts cstddef
 concepts type_traits
 concepts version
 condition_variable atomic
+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
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring

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

 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
 mutex atomic
+mutex cerrno
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
+mutex string
 mutex system_error
 mutex type_traits
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
 new exception
 new type_traits

 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
 ostream atomic
 ostream bitset
+ostream cerrno
 ostream concepts
 ostream cstddef
 ostream cstdint
 ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
+ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque

 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
 source_location version
 span array
 span concepts
 span cstddef

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional
 thread iosfwd
 thread limits
 thread locale
 thread new
 thread ratio
+thread stdexcept
 thread string
 thread string_view
 thread system_error
 thread tuple
 thread type_traits
 thread vector
 thread version
 tuple compare

libcxx/test/libcxx/transitive_includes/cxx11.csv

 complex sstream
 complex stdexcept
 complex type_traits
 complex version
 concepts cstddef
 concepts type_traits
 concepts version
 condition_variable atomic
+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
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring

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

 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
 mutex atomic
+mutex cerrno
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
+mutex string
 mutex system_error
 mutex tuple
 mutex type_traits
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
 new exception

 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
 ostream atomic
 ostream bitset
+ostream cerrno
 ostream concepts
 ostream cstddef
 ostream cstdint
 ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
+ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque

 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
 source_location version
 span array
 span concepts
 span cstddef

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional
 thread iosfwd
 thread limits
 thread locale
 thread new
 thread ratio
+thread stdexcept
 thread string
 thread string_view
 thread system_error
 thread tuple
 thread type_traits
 thread vector
 thread version
 tuple compare

libcxx/test/libcxx/transitive_includes/cxx14.csv

 complex sstream
 complex stdexcept
 complex type_traits
 complex version
 concepts cstddef
 concepts type_traits
 concepts version
 condition_variable atomic
+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
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring

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

 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
 mutex atomic
+mutex cerrno
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
+mutex string
 mutex system_error
 mutex tuple
 mutex type_traits
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
 new exception

 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
 ostream atomic
 ostream bitset
+ostream cerrno
 ostream concepts
 ostream cstddef
 ostream cstdint
 ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
+ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque

 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
 source_location version
 span array
 span concepts
 span cstddef

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional
 thread iosfwd
 thread limits
 thread locale
 thread new
 thread ratio
+thread stdexcept
 thread string
 thread string_view
 thread system_error
 thread tuple
 thread type_traits
 thread vector
 thread version
 tuple compare

libcxx/test/libcxx/transitive_includes/cxx17.csv

 complex sstream
 complex stdexcept
 complex type_traits
 complex version
 concepts cstddef
 concepts type_traits
 concepts version
 condition_variable atomic
+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
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring

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

 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
 mutex atomic
+mutex cerrno
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
+mutex string
 mutex system_error
 mutex tuple
 mutex type_traits
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
 new exception

 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
 ostream atomic
 ostream bitset
+ostream cerrno
 ostream concepts
 ostream cstddef
 ostream cstdint
 ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
+ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque

 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
 source_location version
 span array
 span concepts
 span cstddef

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread cerrno
 thread chrono
 thread compare
 thread cstddef
 thread cstdint
 thread cstring
 thread ctime
 thread functional
 thread iosfwd
 thread limits
 thread locale
 thread new
 thread ratio
+thread stdexcept
 thread string
 thread string_view
 thread system_error
 thread tuple
 thread type_traits
 thread vector
 thread version
 tuple compare

libcxx/test/libcxx/transitive_includes/cxx20.csv

 complex sstream
 complex stdexcept
 complex type_traits
 complex version
 concepts cstddef
 concepts type_traits
 concepts version
 condition_variable atomic
+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
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring

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

 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
 mutex atomic
+mutex cerrno
 mutex concepts
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex cstring
 mutex ctime
 mutex functional
 mutex initializer_list
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
+mutex string
 mutex system_error
 mutex tuple
 mutex type_traits
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
 new exception

 optional tuple
 optional type_traits
 optional typeinfo
 optional utility
 optional variant
 optional version
 ostream atomic
 ostream bitset
+ostream cerrno
 ostream concepts
 ostream cstddef
 ostream cstdint
 ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream iterator
 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
+ostream string
 ostream type_traits
 ostream typeinfo
 ostream version
 queue compare
 queue concepts
 queue cstddef
 queue cstdlib
 queue deque

 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
 source_location version
 span array
 span concepts
 span cstddef

 system_error cstdint
 system_error cstring
 system_error limits
 system_error stdexcept
 system_error string
 system_error type_traits
 system_error version
 thread array
+thread cerrno
 thread compare
 thread cstddef
 thread cstdint
 thread cstdlib
 thread cstring
 thread ctime
 thread functional
 thread iosfwd

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 compare version
 complex cmath
 complex iosfwd
 complex sstream
 complex stdexcept
 complex version
 concepts cstddef
 concepts version
+condition_variable cerrno
 condition_variable cstddef
 condition_variable cstdlib
 condition_variable ctime
 condition_variable iosfwd
 condition_variable limits
 condition_variable new
 condition_variable ratio
 condition_variable stdexcept
-condition_variable system_error
+condition_variable string
 condition_variable typeinfo
 condition_variable version
 coroutine compare
 coroutine cstddef
 coroutine cstdint
 coroutine cstring
 coroutine limits
 coroutine version

 filesystem iomanip
 filesystem iosfwd
 filesystem limits
 filesystem locale
 filesystem new
 filesystem ratio
 filesystem string
 filesystem string_view
-filesystem system_error
 filesystem version
 format array
 format cmath
 format cstddef
 format cstdint
 format cstdlib
 format initializer_list
 format limits

 functional memory
 functional new
 functional stdexcept
 functional tuple
 functional typeinfo
 functional unordered_map
 functional vector
 functional version
+future cerrno
 future cstddef
 future cstdint
 future cstdlib
 future cstring
 future initializer_list
 future iosfwd
 future limits
 future mutex
 future new
 future ratio
 future stdexcept
-future system_error
+future string
 future thread
 future typeinfo
 future version
 initializer_list cstddef
 iomanip istream
 iomanip version
 ios cctype
 ios cstddef
 ios cstdint
 ios cstring
 ios iosfwd
 ios mutex
 ios string
-ios system_error
 ios version
 iosfwd version
 iostream ios
 iostream istream
 iostream ostream
 iostream streambuf
 iostream version
 istream cstddef

 memory_resource cstddef
 memory_resource cstdint
 memory_resource limits
 memory_resource mutex
 memory_resource new
 memory_resource stdexcept
 memory_resource tuple
 memory_resource version
+mutex cerrno
 mutex cstddef
 mutex cstdint
 mutex cstdlib
 mutex ctime
 mutex iosfwd
 mutex limits
 mutex new
 mutex ratio
 mutex stdexcept
-mutex system_error
+mutex string
 mutex tuple
 mutex typeinfo
 mutex version
 new cstddef
 new cstdlib
 new version
 numbers version
 numeric cmath
 numeric cstddef
 numeric limits
 numeric version
 optional compare
 optional cstddef
 optional cstdint
 optional cstring
 optional initializer_list
 optional limits
 optional new
 optional stdexcept
 optional version
 ostream bitset
+ostream cerrno
 ostream cstddef
 ostream cstdint
 ostream cstdlib
 ostream cstring
 ostream initializer_list
 ostream ios
 ostream iosfwd
 ostream limits
 ostream locale
 ostream new
 ostream stdexcept
 ostream streambuf
+ostream string
 ostream typeinfo
 ostream version
 queue compare
 queue cstddef
 queue cstdlib
 queue deque
 queue initializer_list
 queue limits

 set tuple
 set version
 shared_mutex cerrno
 shared_mutex cstddef
 shared_mutex ctime
 shared_mutex iosfwd
 shared_mutex limits
 shared_mutex ratio
-shared_mutex system_error
+shared_mutex stdexcept
+shared_mutex string
 shared_mutex version
 source_location cstdint
 source_location version
 span array
 span cstddef
 span initializer_list
 span limits
 span version

 string_view stdexcept
 string_view version
 strstream istream
 strstream ostream
 strstream version
 system_error cerrno
 system_error compare
 system_error cstddef
-system_error cstdint
-system_error cstring
-system_error limits
 system_error stdexcept
 system_error string
 system_error version
 thread array
+thread cerrno
 thread compare
 thread cstddef
 thread cstdint
 thread cstdlib
 thread ctime
 thread iosfwd
 thread limits
 thread locale
 thread ratio
 thread stdexcept
 thread string
 thread string_view
-thread system_error
 thread tuple
 thread vector
 thread version
 tuple compare
 tuple cstddef
 tuple version
 type_traits cstddef
 type_traits cstdint

libcxx/test/std/diagnostics/syserr/is_error_condition_enum.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
 
 // <system_error>
 
 // template <class T> constexpr bool is_error_condition_enum_v;
 
+#include <string>
 #include <system_error>
 #include <type_traits>
 #include "test_macros.h"
 
 template <bool Expected, class T>
 void
 test()
 {

libcxx/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.constructors/ErrorCodeEnum.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
 //
 //===----------------------------------------------------------------------===//
 
 // <system_error>
 
 // class error_code
 
 // template <ErrorCodeEnum E> error_code(E e);
 
 #include <system_error>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 enum testing
 {
     zero, one, two
 };
 

libcxx/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.modifiers/ErrorCodeEnum.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
 //
 //===----------------------------------------------------------------------===//
 
 // <system_error>
 
 // class error_code
 
 // template <ErrorCodeEnum E> error_code& operator=(E e);
 
 #include <system_error>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 
 enum testing
 {
     zero, one, two
 };
 

libcxx/test/std/numerics/rand/rand.device/ctor.pass.cpp

 // explicit random_device(const string& token);                          // C++20
 
 // For the following ctors, the standard states: "The semantics and default
 // value of the token parameter are implementation-defined". Implementations
 // therefore aren't required to accept any string, but the default shouldn't
 // throw.
 
 #include <random>
+#include <string>
 #include <system_error>
 #include <cassert>
 
 #if !defined(_WIN32)
 #include <unistd.h>
 #endif
 
 #include "test_macros.h"

libcxx/test/std/numerics/rand/rand.device/eval.pass.cpp

 // <random>
 
 // class random_device;
 
 // result_type operator()();
 
 #include <random>
 #include <cassert>
+#include <string>
 #include <system_error>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::random_device r;

libcxx/test/std/thread/futures/futures.errors/default_error_condition.pass.cpp

 // <future>
 
 // const error_category& future_category();
 
 // virtual error_condition default_error_condition(int ev) const;
 
 #include <future>
 #include <cassert>
+#include <system_error>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     const std::error_category& e_cat = std::future_category();
     std::error_condition e_cond = e_cat.default_error_condition(static_cast<int>(std::errc::not_a_directory));
     assert(e_cond.category() == e_cat);
     assert(e_cond.value() == static_cast<int>(std::errc::not_a_directory));
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/lock.pass.cpp

 
 // void lock();
 
 #include <cassert>
 #include <chrono>
 #include <cstdlib>
 #include <mutex>
 #include <shared_mutex>
+#include <system_error>
 #include <thread>
 #include <vector>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::shared_timed_mutex m;
 

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/unlock.pass.cpp

 // <shared_mutex>
 
 // template <class Mutex> class shared_lock;
 
 // void unlock();
 
 #include <shared_mutex>
 #include <cassert>
+#include <cerrno>
 #include <system_error>
 
 #include "test_macros.h"
 
 bool unlock_called = false;
 
 struct mutex
 {

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp

 // template <class Mutex> class unique_lock;
 
 // void lock();
 
 #include <cassert>
 #include <chrono>
 #include <cstdlib>
 #include <mutex>
+#include <system_error>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 
 std::mutex m;
 
 typedef std::chrono::system_clock Clock;

libcxx/utils/data/ignore_format.txt

 libcxx/include/__support/ibm/gettod_zos.h
 libcxx/include/__support/ibm/locale_mgmt_zos.h
 libcxx/include/__support/ibm/nanosleep.h
 libcxx/include/__support/ibm/xlocale.h
 libcxx/include/__support/newlib/xlocale.h
 libcxx/include/__support/solaris/xlocale.h
 libcxx/include/__support/win32/locale_win32.h
 libcxx/include/__support/xlocale/__nop_locale_mgmt.h
-libcxx/include/system_error
+libcxx/include/__system_error/error_category.h
+libcxx/include/__system_error/error_code.h
+libcxx/include/__system_error/error_condition.h
+libcxx/include/__system_error/system_error.h
 libcxx/include/thread
 libcxx/include/__threading_support
 libcxx/include/__thread/poll_with_backoff.h
 libcxx/include/__thread/timed_backoff_policy.h
 libcxx/include/__tree
 libcxx/include/tuple
 libcxx/include/__tuple_dir/apply_cv.h
 libcxx/include/__tuple_dir/make_tuple_types.h