[libc++] Ensure that all public C++ headers include <__assert>

[ldionne]

Summary

This patch changes the requirement for getting the declaration of the
assertion handler from including <__assert> to including any public
C++ header of the library. Note that C compatibility headers are
excluded because we don't implement all the C headers ourselves --
some of them are taken straight from the C library, like assert.h.

It also adds a generated test to check it. Furthermore, this new
generated test is designed in a way that will make it possible to
replace almost all the existing test-generation scripts with this
system in upcoming patches.

[ldionne]

Address CI failures.

The assertion handler won't be available after including C compatibility headers, because it's really difficult to provide that guarantee without implementing more C headers than we do today. In practice, I don't think this should matter since users can include any other header they like.

[ldionne]

Fix modules issue.

[ldionne]

Hopefully fix last CI issues.

[Mordante]

In general quite happy. I think we can do some more minor improvement.

libcxx/include/ext/hash_map

207

Just curious did this fail to compile?

libcxx/include/filesystem

12

Please change to one blank line.

libcxx/include/version

196

I wonder when we include the __assert here, how do you feel about requiring version in every header instead?
When not, maybe extend the script to also always validate version is included? Looking at the number of proposals adding this header, soon every header will require them.

libcxx/utils/generate_assertion_tests.py

11

This code feels duplicated. I don't care too strongly about it, but when we keep duplicating it more times we maybe should look at having one source of truth for these lists.

21

I think this restriction isn't required it's safe to include this header when format is disabled.

33

I think this restriction isn't required it's safe to include this header when ranges are disabled.

45

I think this restriction isn't required it's safe to include this header when coroutines are disabled.

57

Except for experimental/regex I don't see an #error in these headers. Do we need them in this list?

[ldionne]

Address review comments!

libcxx/include/ext/hash_map

207

Yeah, this started failing to compile, I think it's because previously we never included ext/hash_map alone in a file, we always had other headers, and <algorithm> was probably always included before ext/hash_map.

libcxx/include/version

196

I'd be fine with that, although we most likely want to include <version> in all C++ headers only (not C compatibility headers, for the same reason as here). I volunteer to do it in a separate patch.

libcxx/utils/generate_assertion_tests.py

11

I fully agree -- maybe it wasn't clear, but I have a follow-on patch locally that removes all the other header generation scripts.

57

We do, because they use C++03-unfriendly constructs in the headers. That's why they were guarded similarly in previous header-generation tests, too.

[Mordante]

LGTM! I've some replies but they require no actions.

libcxx/include/version

196

Thanks for volunteering!

libcxx/utils/generate_assertion_tests.py

11

That wasn't clear, but sounds good!

libcxx/docs/UsingLibcxx.rst

.. code-block:: cpp
   void __libcpp_assertion_handler(char const* file, int line, char const* expression, char const* message)
 
 This mechanism is similar to how one can replace the default definition of ``operator new``
 and ``operator delete``. For example:
 
 .. code-block:: cpp
 
   // In HelloWorldHandler.cpp
-  #include <__assert> // must include <__assert> before defining the handler
+  #include <version> // must include any libc++ header before defining the handler (C compatibility headers excluded)
 
   void std::__libcpp_assertion_handler(char const* file, int line, char const* expression, char const* message) {
     std::printf("Assertion %s failed at %s:%d, more info: %s", expression, file, line, message);
     std::abort();
   }
 
   // In HelloWorld.cpp
   #include <vector>

libcxx/include/algorithm

 
 template <class BidirectionalIterator, class Compare>
     constexpr bool     // constexpr in C++20
     prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__bits>
 #include <__config>
 #include <__debug>
 #include <cstddef>
 #include <cstring>
 #include <functional>
 #include <initializer_list>
 #include <iterator>

libcxx/include/any

template<class ValueType>
     const ValueType* any_cast(const any* operand) noexcept;
   template<class ValueType>
     ValueType* any_cast(any* operand) noexcept;
 
 } // namespace std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstdlib>
 #include <memory>

libcxx/include/array

 }  // std
 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/swap_ranges.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__tuple>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>

libcxx/include/atomic

 #define ATOMIC_VAR_INIT(value) see below
 
 #define ATOMIC_FLAG_INIT see below
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__config>
 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>

libcxx/include/barrier

namespace std
   private:
     CompletionFunction completion; // exposition only
   };
 
 }
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__thread/timed_backoff_policy.h>
 #include <atomic>
 #ifndef _LIBCPP_HAS_NO_TREE_BARRIER
 # include <memory>
 #endif
 

libcxx/include/bit

enum class endian {
     big = see below,           // C++20
     native = see below         // C++20
   };
 
 } // namespace std
 
 */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit/bit_cast.h>
 #include <__bit/byteswap.h>
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <limits>
 #include <type_traits>
 #include <version>
 

libcxx/include/bitset

 
 template <size_t N> struct hash<std::bitset<N>>;
 
 }  // std
 
 */
 
 #include <__algorithm/fill.h>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit_reference>
 #include <__config>
 #include <__functional/unary_function.h>
 #include <climits>
 #include <cstddef>
 #include <iosfwd>
 #include <stdexcept>
 #include <string>

libcxx/include/cassert

/*
     cassert synopsis
 
 Macros:
 
     assert
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <assert.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/ccomplex

 
 /*
     ccomplex synopsis
 
 #include <complex>
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <complex>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-// hh 080623 Created
-
 #endif // _LIBCPP_CCOMPLEX

libcxx/include/cctype

 int isupper(int c);
 int isxdigit(int c);
 int tolower(int c);
 int toupper(int c);
 
 }  // std
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <ctype.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/cerrno

Macros:
 
     EDOM
     EILSEQ  // C99
     ERANGE
     errno
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <errno.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_CERRNO

libcxx/include/cfenv

 int fegetenv(fenv_t* envp);
 int feholdexcept(fenv_t* envp);
 int fesetenv(const fenv_t* envp);
 int feupdateenv(const fenv_t* envp);
 
 }  // std
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <fenv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/cfloat

Macros:
     DBL_MIN
     LDBL_MIN
 
     FLT_TRUE_MIN        // C11
     DBL_TRUE_MIN        // C11
     LDBL_TRUE_MIN       // C11
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <float.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_CFLOAT

libcxx/include/charconv

namespace std {
   from_chars_result from_chars(const char* first, const char* last,
                                long double& value,
                                chars_format fmt = chars_format::general);
 
 } // namespace std
 
 */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__bits>
 #include <__charconv/chars_format.h>
 #include <__charconv/from_chars_result.h>
 #include <__charconv/to_chars_result.h>
 #include <__config>
 #include <__debug>
 #include <__errc>

libcxx/include/chrono

 constexpr chrono::day                                   operator ""d(unsigned long long d) noexcept; // C++20
 constexpr chrono::year                                  operator ""y(unsigned long long y) noexcept; // C++20
 }  // chrono_literals
 }  // literals
 
 }  // std
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__chrono/calendar.h>
 #include <__chrono/convert_to_timespec.h>
 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
 #include <__chrono/high_resolution_clock.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>

libcxx/include/cinttypes

 intmax_t  strtoimax(const char* restrict nptr, char** restrict endptr, int base);
 uintmax_t strtoumax(const char* restrict nptr, char** restrict endptr, int base);
 intmax_t  wcstoimax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int base);
 uintmax_t wcstoumax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int base);
 
 }  // std
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cstdint>
 #include <inttypes.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/ciso646

 #ifndef _LIBCPP_CISO646
 #define _LIBCPP_CISO646
 
 /*
     ciso646 synopsis
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_CISO646

libcxx/include/climits

Macros:
     LONG_MAX
     ULONG_MAX
     LLONG_MIN   // C99
     LLONG_MAX   // C99
     ULLONG_MAX  // C99
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <limits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_CLIMITS

libcxx/include/clocale

 struct lconv;
 char* setlocale(int category, const char* locale);
 lconv* localeconv();
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <locale.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::lconv _LIBCPP_USING_IF_EXISTS;
 using ::setlocale _LIBCPP_USING_IF_EXISTS;
 using ::localeconv _LIBCPP_USING_IF_EXISTS;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_CLOCALE

libcxx/include/cmath

 constexpr float       lerp(float a, float b, float t) noexcept;                   // C++20
 constexpr double      lerp(double a, double b, double t) noexcept;                // C++20
 constexpr long double lerp(long double a, long double b, long double t) noexcept; // C++20
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <math.h>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/codecvt

class codecvt_utf8_utf16
     explicit codecvt_utf8_utf16(size_t refs = 0);
     ~codecvt_utf8_utf16();
 };
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__locale>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/compare

public:
     friend constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
     friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
     friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
 }
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__compare/common_comparison_category.h>
 #include <__compare/compare_partial_order_fallback.h>
 #include <__compare/compare_strong_order_fallback.h>
 #include <__compare/compare_three_way.h>
 #include <__compare/compare_three_way_result.h>
 #include <__compare/compare_weak_order_fallback.h>
 #include <__compare/is_eq.h>
 #include <__compare/ordering.h>

libcxx/include/complex

 template<class T> complex<T> sqrt (const complex<T>&);
 template<class T> complex<T> tan (const complex<T>&);
 template<class T> complex<T> tanh (const complex<T>&);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cmath>
 #include <iosfwd>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)

libcxx/include/concepts

namespace std {
 
   // [concept.strictweakorder], concept strict_weak_order
   template<class R, class T, class U>
     concept strict_weak_order = see below;
 }
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__concepts/arithmetic.h>
 #include <__concepts/assignable.h>
 #include <__concepts/boolean_testable.h>
 #include <__concepts/class_or_enum.h>
 #include <__concepts/common_reference_with.h>
 #include <__concepts/common_with.h>
 #include <__concepts/constructible.h>
 #include <__concepts/convertible_to.h>

libcxx/include/condition_variable

template <class Lock, class Rep, class Period, class Predicate>
                  const chrono::duration<Rep, Period>& rel_time,
                  Predicate pred);
 };
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__mutex_base>
 #include <memory>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/coroutine

 noop_coroutine_handle noop_coroutine() noexcept;
 // [coroutine.trivial.awaitables]
 struct suspend_never;
 struct suspend_always;
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__coroutine/coroutine_handle.h>
 #include <__coroutine/coroutine_traits.h>
 #include <__coroutine/noop_coroutine_handle.h>
 #include <__coroutine/trivial_awaitables.h>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_COROUTINE

libcxx/include/csetjmp

Types:
     jmp_buf
 
 void longjmp(jmp_buf env, int val);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <setjmp.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::jmp_buf _LIBCPP_USING_IF_EXISTS;
 using ::longjmp _LIBCPP_USING_IF_EXISTS;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_CSETJMP

libcxx/include/csignal

 
 void (*signal(int sig, void (*func)(int)))(int);
 int raise(int sig);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <signal.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::sig_atomic_t _LIBCPP_USING_IF_EXISTS;
 using ::signal _LIBCPP_USING_IF_EXISTS;
 using ::raise _LIBCPP_USING_IF_EXISTS;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_CSIGNAL

libcxx/include/cstdarg

 Types:
 
     va_list
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <stdarg.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::va_list _LIBCPP_USING_IF_EXISTS;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_CSTDARG

libcxx/include/cstdbool

/*
     cstdbool synopsis
 
 Macros:
 
     __bool_true_false_are_defined
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #undef __bool_true_false_are_defined
 #define __bool_true_false_are_defined 1
 
 #endif // _LIBCPP_CSTDBOOL

libcxx/include/cstddef

Types:
     max_align_t // C++11
     nullptr_t
     byte // C++17
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <stddef.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/cstdint

Types:
     uintptr_t
 
     intmax_t
     uintmax_t
 
 }  // std
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <stdint.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/cstdio

 void clearerr(FILE* stream);
 int feof(FILE* stream);
 int ferror(FILE* stream);
 void perror(const char* s);
 
 }  // std
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <stdio.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/cstdlib

 int at_quick_exit(void (*func)(void))                                     // C++11
 void quick_exit(int status);                                              // C++11
 void *aligned_alloc(size_t alignment, size_t size);                       // C11
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <stdlib.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/cstring

 void* memset(void* s, int c, size_t n);
 char* strerror(int errnum);
 size_t strlen(const char* s);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <string.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/ctgmath

 /*
     ctgmath synopsis
 
 #include <ccomplex>
 #include <cmath>
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <ccomplex>
 #include <cmath>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_CTGMATH

libcxx/include/ctime

 tm* localtime(const time_t* timer);
 size_t strftime(char* restrict s, size_t maxsize, const char* restrict format,
                 const tm* restrict timeptr);
 int timespec_get( struct timespec *ts, int base); // C++17
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <time.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/cuchar

 size_t c16rtomb(char* s, char16_t c16, mbstate_t* ps);
 size_t mbrtoc32(char32_t* pc32, const char* s, size_t n, mbstate_t* ps);
 size_t c32rtomb(char* s, char32_t c32, mbstate_t* ps);
 
 } // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <uchar.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/cwchar

size_t mbsrtowcs(wchar_t* restrict dst, const char** restrict src, size_t len,
                  mbstate_t* restrict ps);
 size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
                  mbstate_t* restrict ps);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cwctype>
 #include <wchar.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/cwctype

 wint_t towupper(wint_t wc);
 wint_t towctrans(wint_t wc, wctrans_t desc);
 wctrans_t wctrans(const char* property);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cctype>
 #include <wctype.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/deque

 #include <__algorithm/copy_backward.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/unwrap_iter.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <initializer_list>

libcxx/include/exception

 
 template <class T> [[noreturn]] void throw_with_nested(T&& t);
 template <class E> void rethrow_if_nested(const E& e);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__memory/addressof.h>
 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>
 #include <version>
 

libcxx/include/execution

 // -*- 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_EXECUTION
 #define _LIBCPP_EXECUTION
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <version>
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_execution>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_EXECUTION

libcxx/include/experimental/algorithm

 // sample removed because it's now part of C++17
 
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__debug>
 #include <algorithm>
 #include <experimental/__config>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/experimental/coroutine

 template <class P> struct hash<coroutine_handle<P>>;
 
 } // namespace coroutines_v1
 } // namespace experimental
 } // namespace std
 
  */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <cstddef>
 #include <experimental/__config>
 #include <functional>
 #include <memory> // for hash<T*>
 #include <new>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/experimental/deque

 // -*- 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_EXPERIMENTAL_DEQUE
 #define _LIBCPP_EXPERIMENTAL_DEQUE
+
 /*
     experimental/deque synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
   template <class T>
   using deque = std::deque<T,polymorphic_allocator<T>>;
 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <deque>
 #include <experimental/__config>
 #include <experimental/memory_resource>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
 
 template <class _ValueT>
 using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>;
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 #endif /* _LIBCPP_EXPERIMENTAL_DEQUE */

libcxx/include/experimental/forward_list

 // -*- 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_EXPERIMENTAL_FORWARD_LIST
 #define _LIBCPP_EXPERIMENTAL_FORWARD_LIST
+
 /*
     experimental/forward_list synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
   template <class T>
   using forward_list = std::forward_list<T,polymorphic_allocator<T>>;
 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <forward_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
 
 template <class _ValueT>
 using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 #endif /* _LIBCPP_EXPERIMENTAL_FORWARD_LIST */

libcxx/include/experimental/functional

inline namespace fundamentals_v1 {
 
   } // namespace fundamentals_v1
   } // namespace experimental
 
 } // namespace std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__debug>
 #include <__memory/uses_allocator.h>
 #include <array>
 #include <experimental/__config>
 #include <functional>
 #include <type_traits>
 #include <unordered_map>
 #include <vector>

libcxx/include/experimental/iterator

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

libcxx/include/experimental/list

 // -*- 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_EXPERIMENTAL_LIST
 #define _LIBCPP_EXPERIMENTAL_LIST
+
 /*
     experimental/list synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
   template <class T>
   using list = std::list<T,polymorphic_allocator<T>>;
 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
 
 template <class _ValueT>
 using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>;
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 #endif /* _LIBCPP_EXPERIMENTAL_LIST */

libcxx/include/experimental/map

 // -*- 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_EXPERIMENTAL_MAP
 #define _LIBCPP_EXPERIMENTAL_MAP
+
 /*
     experimental/map synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
   template <class Key, class T, class Compare = less<Key>>
   using map = std::map<Key, T, Compare,
                        polymorphic_allocator<pair<const Key,T>>>;
 
   template <class Key, class T, class Compare = less<Key>>
   using multimap = std::multimap<Key, T, Compare,
                                  polymorphic_allocator<pair<const Key,T>>>;
 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <map>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/experimental/memory_resource

 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__tuple>
 #include <__utility/move.h>
 #include <cstddef>
 #include <cstdlib>
 #include <experimental/__config>
 #include <experimental/__memory>
 #include <limits>
 #include <memory>

libcxx/include/experimental/propagate_const

 // -*- 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_EXPERIMENTAL_PROPAGATE_CONST
 #define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+
 /*
     propagate_const synopsis
 
     namespace std { namespace experimental { inline namespace fundamentals_v2 {
 
     // [propagate_const]
     template <class T> class propagate_const;
 
/*
   template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
   template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
   template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
 
 } // namespace std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <experimental/__config>
 #include <functional>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/experimental/regex

 // -*- 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_EXPERIMENTAL_REGEX
 #define _LIBCPP_EXPERIMENTAL_REGEX
+
 /*
     experimental/regex synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {

 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <experimental/string>
 #include <regex>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/experimental/set

 // -*- 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_EXPERIMENTAL_SET
 #define _LIBCPP_EXPERIMENTAL_SET
+
 /*
     experimental/set synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
   template <class Key, class T, class Compare = less<Key>>
   using set = std::set<Key, T, Compare,
                        polymorphic_allocator<pair<const Key,T>>>;
 
   template <class Key, class T, class Compare = less<Key>>
   using multiset = std::multiset<Key, T, Compare,
                                  polymorphic_allocator<pair<const Key,T>>>;
 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <set>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/experimental/simd

public:
   friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
 };
 
 } // parallelism_v2
 } // std::experimental
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <array>
 #include <cstddef>
 #include <experimental/__config>
 #include <functional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/experimental/string

 // -*- 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_EXPERIMENTAL_STRING
 #define _LIBCPP_EXPERIMENTAL_STRING
+
 /*
     experimental/string synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {

 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/experimental/type_traits

constexpr bool is_detected_convertible_v
        = is_detected_convertible<To, Op, Args...>::value;
 
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 
 #if _LIBCPP_STD_VER > 11
 
 #include <initializer_list>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/experimental/unordered_map

 // -*- 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_EXPERIMENTAL_UNORDERED_MAP
 #define _LIBCPP_EXPERIMENTAL_UNORDERED_MAP
+
 /*
     experimental/unordered_map synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {

 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <unordered_map>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/experimental/unordered_set

 // -*- 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_EXPERIMENTAL_UNORDERED_SET
 #define _LIBCPP_EXPERIMENTAL_UNORDERED_SET
+
 /*
     experimental/unordered_set synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
   template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
   using unordered_set = std::unordered_set<T, Hash, Pred,
                        polymorphic_allocator<T>>;
 
   template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
   using unordered_multiset = std::unordered_multiset<T, Hash, Pred,
                        polymorphic_allocator<T>>;
 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <unordered_set>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/experimental/utility

inline namespace fundamentals_v1 {
   struct erased_type { };
 
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
   struct _LIBCPP_TEMPLATE_VIS erased_type { };
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif /* _LIBCPP_EXPERIMENTAL_UTILITY */

libcxx/include/experimental/vector

 // -*- 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_EXPERIMENTAL_VECTOR
 #define _LIBCPP_EXPERIMENTAL_VECTOR
+
 /*
     experimental/vector synopsis
 
 // C++1z
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
   template <class T>
   using vector = std::vector<T, polymorphic_allocator<T>>;
 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <experimental/memory_resource>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
 
 template <class _ValueT>
 using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>;
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 #endif /* _LIBCPP_EXPERIMENTAL_VECTOR */

libcxx/include/ext/hash_map

template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator!=(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
                const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // __gnu_cxx
 
 */
 
-#include <__algorithm/is_permutation.h>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
+#include <algorithm>
 #include <ext/__hash>
 #include <functional>
 #include <stdexcept>
 #include <type_traits>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")

libcxx/include/ext/hash_set

 template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator!=(const hash_multiset<Value, Hash, Pred, Alloc>& x,
                const hash_multiset<Value, Hash, Pred, Alloc>& y);
 }  // __gnu_cxx
 
 */
 
-#include <__algorithm/is_permutation.h>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__hash_table>
+#include <algorithm>
 #include <ext/__hash>
 #include <functional>
 
 #if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
 #else
 #   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>

libcxx/include/filesystem

 // -*- 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
 #define _LIBCPP_FILESYSTEM
+
 /*
     filesystem synopsis
 
     namespace std::filesystem {
 
     class path;
 
     void swap(path& lhs, path& rhs) noexcept;
     size_t hash_value(const path& p) noexcept;

 
 template <>
 inline constexpr bool std::ranges::enable_view<std::filesystem::directory_iterator> = true;
 template <>
 inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__filesystem/copy_options.h>
 #include <__filesystem/directory_entry.h>
 #include <__filesystem/directory_iterator.h>
 #include <__filesystem/directory_options.h>
 #include <__filesystem/file_status.h>
 #include <__filesystem/file_time_type.h>
 #include <__filesystem/file_type.h>

libcxx/include/format

format-arg-store<wformat_context, Args...>
       make_wformat_args(const Args&... args);
 
   // [format.error], class format_error
   class format_error;
 }
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 // Make sure all feature-test macros are available.
 #include <version>
 // Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES.
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
 
 #include <__algorithm/clamp.h>
 #include <__config>
 #include <__debug>

libcxx/include/forward_list

 
 }  // std
 
 */
 
 #include <__algorithm/comp.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/min.h>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__utility/forward.h>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>

libcxx/include/fstream

 typedef basic_fstream<char>    fstream;
 typedef basic_fstream<wchar_t> wfstream;
 
 }  // std
 
 */
 
 #include <__algorithm/max.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <cstdio>
 #include <cstdlib>

libcxx/include/functional

 
 POLICY:  For non-variadic implementations, the number of arguments is limited
          to 3.  It is hoped that the need for non-variadic implementations
          will be minimal.
 
 */
 
 #include <__algorithm/search.h>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__compare/compare_three_way.h>
 #include <__config>
 #include <__debug>
 #include <__functional/binary_function.h> // TODO: deprecate
 #include <__functional/binary_negate.h>
 #include <__functional/bind.h>
 #include <__functional/bind_back.h>
 #include <__functional/bind_front.h>

libcxx/include/future

template <class R>
   void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept;
 
 template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 
 }  // std
 
 */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>

libcxx/include/initializer_list

 
 template<class E> const E* begin(initializer_list<E> il) noexcept; // constexpr in C++14
 template<class E> const E* end(initializer_list<E> il) noexcept; // constexpr in C++14
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 namespace std  // purposefully not versioned

libcxx/include/iomanip

 template <class charT, class traits, class Allocator>
   T13 quoted(basic_string<charT, traits, Allocator>& s,
              charT delim=charT('"'), charT escape=charT('\\')); // C++14
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__string>
 #include <istream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/ios

 error_code make_error_code(io_errc e) noexcept;
 error_condition make_error_condition(io_errc e) noexcept;
 storage-class-specifier const error_category& iostream_category() noexcept;
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__ios/fpos.h>
 #include <__locale>
 #include <__utility/swap.h>
 #include <iosfwd>
 #include <system_error>
 #include <version>
 

libcxx/include/iosfwd

 using u8streampos = fpos<char_traits<char8_t>::state_type>; // C++20
 using u16streampos = fpos<char_traits<char16_t>::state_type>;
 using u32streampos = fpos<char_traits<char32_t>::state_type>;
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__mbstate_t.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/iostream

 extern wostream wcout;
 extern wostream wcerr;
 extern wostream wclog;
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <ios>
 #include <istream>
 #include <ostream>
 #include <streambuf>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/istream

 // rvalue stream extraction
 template <class Stream, class T>
   Stream&& operator>>(Stream&& is, T&& x);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__utility/forward.h>
 #include <ostream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/iterator

 template <class C> constexpr auto data(const C& c) -> decltype(c.data());         // C++17
 template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;           // C++17
 template <class E> constexpr const E* data(initializer_list<E> il) noexcept;      // C++17
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__iterator/access.h>
 #include <__iterator/advance.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/common_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/counted_iterator.h>

libcxx/include/latch

namespace std
   private:
     ptrdiff_t __counter; // exposition only
   };
 
 }
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <atomic>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/limits

 
 template<> class numeric_limits<cv float>;
 template<> class numeric_limits<cv double>;
 template<> class numeric_limits<cv long double>;
 
 }  // std
 
 */
+
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <type_traits>
 
 #if defined(_LIBCPP_COMPILER_MSVC)
 #include "__support/win32/limits_msvc_win32.h"
 #endif // _LIBCPP_MSVCRT
 
 #if defined(__IBMCPP__)

libcxx/include/list

 }  // std
 
 */
 
 #include <__algorithm/comp.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/min.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <initializer_list>
 #include <iterator>
 #include <limits>

libcxx/include/locale

 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/find.h>
 #include <__algorithm/max.h>
 #include <__algorithm/reverse.h>
 #include <__algorithm/unwrap_iter.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__locale>
 #ifndef __APPLE__
 # include <cstdarg>
 #endif
 #include <cstdio>
 #include <cstdlib>

libcxx/include/map

 erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <__utility/swap.h>
 #include <compare>

libcxx/include/memory

template <class T, class Alloc>
   inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/concepts.h>

libcxx/include/mutex

 
 template<class Callable, class ...Args>
   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__mutex_base>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #ifndef _LIBCPP_CXX03_LANG

libcxx/include/new

 
 void* operator new  (std::size_t size, void* ptr) noexcept;             // nodiscard in C++20
 void* operator new[](std::size_t size, void* ptr) noexcept;             // nodiscard in C++20
 void  operator delete  (void* ptr, void*) noexcept;
 void  operator delete[](void* ptr, void*) noexcept;
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <cstddef>
 #include <cstdlib>
 #include <exception>
 #include <type_traits>
 #include <version>
 

libcxx/include/numbers

namespace std::numbers {
   inline constexpr double sqrt2      = sqrt2_v<double>;
   inline constexpr double sqrt3      = sqrt3_v<double>;
   inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
   inline constexpr double egamma     = egamma_v<double>;
   inline constexpr double phi        = phi_v<double>;
 }
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <concepts>
 #include <type_traits>
 #include <version>
 
 #if _LIBCPP_STD_VER > 17
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/numeric

 
 template<class T>
     constexpr T* midpoint(T* a, T* b);        // C++20
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cmath> // for isnormal
 #include <functional>
 #include <iterator>
 #include <version>
 
 #include <__numeric/accumulate.h>
 #include <__numeric/adjacent_difference.h>

libcxx/include/optional

 
 template<class T>
   optional(T) -> optional<T>;
 
 } // namespace std
 
 */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__concepts/invocable.h>
 #include <__config>
 #include <__utility/in_place.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>

libcxx/include/ostream

 // rvalue stream insertion
 template <class Stream, class T>
   Stream&& operator<<(Stream&& os, const T& x);
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <bitset>
 #include <ios>
 #include <iterator>
 #include <locale>
 #include <streambuf>
 #include <version>
 

libcxx/include/queue

 
 }  // std
 
 */
 
 #include <__algorithm/make_heap.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/push_heap.h>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <compare>
 #include <deque>
 #include <functional>
 #include <type_traits>

libcxx/include/random

class piecewise_linear_distribution
     basic_istream<charT, traits>&
     operator>>(basic_istream<charT, traits>& is,
                piecewise_linear_distribution& x);
 };
 
 } // std
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__random/bernoulli_distribution.h>
 #include <__random/binomial_distribution.h>
 #include <__random/cauchy_distribution.h>
 #include <__random/chi_squared_distribution.h>
 #include <__random/clamp_to_integral.h>
 #include <__random/default_random_engine.h>
 #include <__random/discard_block_engine.h>

libcxx/include/ranges

namespace std {
 
   template<class I, class S, ranges::subrange_kind K>
   struct tuple_element<1, const ranges::subrange<I, S, K>> {
     using type = S;
   };
 }
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/counted.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>

libcxx/include/ratio

template <class R1, class R2> inline constexpr bool ratio_less_equal_v
     = ratio_less_equal<R1, R2>::value;                                  // C++17
   template <class R1, class R2> inline constexpr bool ratio_greater_v
     = ratio_greater<R1, R2>::value;                                     // C++17
   template <class R1, class R2> inline constexpr bool ratio_greater_equal_v
     = ratio_greater_equal<R1, R2>::value;                               // C++17
 }
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <climits>
 #include <cstdint>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/regex

 typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
 typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 } // std
 */
 
 #include <__algorithm/find.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <compare>
 #include <deque>
 #include <initializer_list>

libcxx/include/scoped_allocator

template <class OuterA1, class OuterA2, class... InnerAllocs>
     bool
     operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__utility/forward.h>
 #include <memory>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/semaphore

 };
 
 using binary_semaphore = counting_semaphore<1>;
 
 }
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <atomic>
 #include <version>
 

libcxx/include/set

 erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <compare>
 #include <functional>

libcxx/include/shared_mutex

 
 template <class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <version>
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/span

 
 template<class R>
     span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
 
 } // namespace std
 
 */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/wrap_iter.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>

libcxx/include/sstream

 
 typedef basic_stringstream<char>    stringstream;
 typedef basic_stringstream<wchar_t> wstringstream;
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__utility/swap.h>
 #include <istream>
 #include <ostream>
 #include <string>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/stack

 template <class T, class Container>
   void swap(stack<T, Container>& x, stack<T, Container>& y)
   noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <deque>
 #include <type_traits>
 #include <version>
 

libcxx/include/stdbool.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_STDBOOL_H
 #define _LIBCPP_STDBOOL_H
 
-
 /*
     stdbool.h synopsis
 
 Macros:
 
     __bool_true_false_are_defined
 
 */

libcxx/include/stdexcept

public:
 
     virtual const char* what() const noexcept // returns what_arg
 };
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cstdlib>
 #include <exception>
 #include <iosfwd>  // for string forward decl
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/streambuf

protected:
     virtual streamsize xsputn(const char_type* s, streamsize n);
     virtual int_type overflow (int_type c = traits_type::eof());
 };
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cstdint>
 #include <ios>
 #include <iosfwd>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/string

 }  // std
 
 */
 
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__ios/fpos.h>
 #include <__iterator/wrap_iter.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <compare>

libcxx/include/string_view

 // -*- 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_STRING_VIEW
 #define _LIBCPP_STRING_VIEW
 
 /*
+
     string_view synopsis
 
 namespace std {
 
     // 7.2, Class template basic_string_view
     template<class charT, class traits = char_traits<charT>>
         class basic_string_view;
 
     template<class charT, class traits>
namespace std {
   constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
 
 */
 
 #include <__algorithm/min.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__string>
 #include <compare>

libcxx/include/strstream

 private:
     strstreambuf sb; // exposition only
 };
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <istream>
 #include <ostream>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/system_error

 
 template <> struct hash<std::error_code>;
 template <> struct hash<std::error_condition>;
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__errc>
 #include <__functional/unary_function.h>
 #include <compare>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <version>

libcxx/include/thread

 void sleep_for(const chrono::duration<Rep, Period>& rel_time);
 
 }  // this_thread
 
 }  // std
 
 */
 
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__mutex_base>
 #include <__thread/poll_with_backoff.h>
 #include <__thread/timed_backoff_policy.h>
 #include <__threading_support>
 #include <__utility/forward.h>
 #include <cstddef>
 #include <functional>

libcxx/include/tuple

 template <class... Types>
   void
   swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__compare/common_comparison_category.h>
 #include <__compare/synth_three_way.h>
 #include <__config>
 #include <__functional/unwrap_ref.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__tuple>
 #include <__utility/forward.h>

libcxx/include/type_traits

template <class...>
         inline constexpr bool disjunction_v = disjunction<B...>::value;  // C++17
       template<class B> struct negation;                                 // C++17
       template<class B>
         inline constexpr bool negation_v = negation<B>::value;           // C++17
 
 }
 
 */
+
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cstddef>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/typeindex

 {
     size_t operator()(type_index index) const noexcept;
 };
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/unary_function.h>
 #include <compare>
 #include <typeinfo>
 #include <version>
 
 // TODO: remove these headers
 #include <__functional/binary_function.h>

libcxx/include/typeinfo

public:
     bad_typeid& operator=(const bad_typeid&) noexcept;
     virtual const char* what() const noexcept;
 };
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <cstddef>
 #include <cstdint>
 #include <exception>
 #include <type_traits>
 
 #ifdef _LIBCPP_NO_EXCEPTIONS

libcxx/include/unordered_map

template <class Key, class T, class Hash, class Pred, class Alloc>
     operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // std
 
 */
 
 #include <__algorithm/is_permutation.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__hash_table>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>

libcxx/include/unordered_set

template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
                const unordered_multiset<Value, Hash, Pred, Alloc>& y);
 }  // std
 
 */
 
 #include <__algorithm/is_permutation.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__hash_table>
 #include <__memory/addressof.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <compare>

libcxx/include/utility

 // [utility.underlying], to_underlying
 template <class T>
     constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
 
 }  // std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__debug>
 #include <__tuple>
 #include <__utility/as_const.h>
 #include <__utility/auto_cast.h>
 #include <__utility/cmp.h>
 #include <__utility/declval.h>
 #include <__utility/exchange.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>

libcxx/include/valarray

 
 #include <__algorithm/copy.h>
 #include <__algorithm/count.h>
 #include <__algorithm/fill.h>
 #include <__algorithm/max_element.h>
 #include <__algorithm/min.h>
 #include <__algorithm/min_element.h>
 #include <__algorithm/unwrap_iter.h>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cmath>
 #include <cstddef>
 #include <functional>
 #include <initializer_list>
 #include <new>
 #include <version>
 

libcxx/include/variant

namespace std {
   template <class T> struct hash;
   template <class... Types> struct hash<variant<Types...>>;
   template <> struct hash<monostate>;
 
 } // namespace std
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <__functional/unary_function.h>
 #include <__tuple>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>

libcxx/include/vector

 #include <__algorithm/copy.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/unwrap_iter.h>
-#include <__assert>
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__bit_reference>
 #include <__config>
 #include <__debug>
 #include <__functional/hash.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
 #include <__split_buffer>
 #include <__utility/forward.h>

libcxx/include/version

 __cpp_lib_unordered_map_try_emplace                     201411L <unordered_map>
 __cpp_lib_unreachable                                   202202L <utility>
 __cpp_lib_unwrap_ref                                    201811L <functional>
 __cpp_lib_variant                                       202102L <variant>
 __cpp_lib_void_t                                        201411L <type_traits>
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 // clang-format off
 

libcxx/test/libcxx/assertions/assertions_disabled.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
 //
 //===----------------------------------------------------------------------===//
 
 // Test that _LIBCPP_ASSERT doesn't do anything when assertions are disabled.
 // We need to use -Wno-macro-redefined because the test suite defines
 // _LIBCPP_ENABLE_ASSERTIONS=1 under some configurations.
 
 // ADDITIONAL_COMPILE_FLAGS: -Wno-macro-redefined -D_LIBCPP_ENABLE_ASSERTIONS=0
 
-#include <__assert>
 #include <cassert>
 
 bool executed_condition = false;
 bool f() { executed_condition = true; return false; }
 
 int main(int, char**) {
   _LIBCPP_ASSERT(f(), "message"); // should not execute anything
   assert(!executed_condition); // really make sure we did not execute anything at all
   return 0;
 }

libcxx/test/libcxx/assertions/customize_handler.backdeployment.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
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that we can enable assertions when we back-deploy to older platforms
 // if we define _LIBCPP_AVAILABILITY_CUSTOM_ASSERTION_HANDLER_PROVIDED.
 //
 // Note that this test isn't really different from customize_handler.pass.cpp when
 // run outside of back-deployment scenarios, but we still run it all the time.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1 -D_LIBCPP_AVAILABILITY_CUSTOM_ASSERTION_HANDLER_PROVIDED
 
-#include <__assert>
 #include <cassert>
 
 bool handler_called = false;
 void std::__libcpp_assertion_handler(char const*, int, char const*, char const*) {
   handler_called = true;
 }
 
 int main(int, char**) {
   _LIBCPP_ASSERT(false, "message");
   assert(handler_called);
   return 0;
 }

libcxx/test/libcxx/assertions/customize_handler.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
 //
 //===----------------------------------------------------------------------===//
 
 // Test that we can set a custom assertion handler.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 // We flag uses of the assertion handler in older dylibs at compile-time to avoid runtime
 // failures when back-deploying.
 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11|12}}
 
-#include <__assert>
 #include <cassert>
 
 bool handler_called = false;
 void std::__libcpp_assertion_handler(char const*, int, char const*, char const*) {
   handler_called = true;
 }
 
 int main(int, char**) {
   _LIBCPP_ASSERT(false, "message");
   assert(handler_called);
   return 0;
 }

libcxx/test/libcxx/assertions/debug_mode_compatibility.pass.cpp

 // it to enable assertions previously.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=0
 
 // We flag uses of the assertion handler in older dylibs at compile-time to avoid runtime
 // failures when back-deploying.
 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11|12}}
 
-#include <__assert>
 #include <cassert>
 
 bool handler_called = false;
 void std::__libcpp_assertion_handler(char const*, int, char const*, char const*) {
   handler_called = true;
 }
 
 int main(int, char**) {
   _LIBCPP_ASSERT(false, "message");
   assert(handler_called);
   return 0;
 }

libcxx/test/libcxx/assertions/default_handler.abort.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
 //
 //===----------------------------------------------------------------------===//
 
 // Test that the default assertion handler aborts the program.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 // We flag uses of the assertion handler in older dylibs at compile-time to avoid runtime
 // failures when back-deploying.
 // UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11|12}}
 
-#include <__assert>
 #include <csignal>
 #include <cstdlib>
 
 void signal_handler(int signal) {
   if (signal == SIGABRT)
     std::_Exit(EXIT_SUCCESS);
   std::_Exit(EXIT_FAILURE);
 }
 
 int main(int, char**) {
   if (std::signal(SIGABRT, signal_handler) != SIG_ERR)
     _LIBCPP_ASSERT(false, "foo");
   return EXIT_FAILURE;
 }

libcxx/test/libcxx/assertions/default_handler.availability.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that we diagnose any usage of the default assertion handler on a platform
 // that doesn't support it at compile-time.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
 // REQUIRES: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11|12}}
 
-#include <__assert>
+#include <version> // any header would work
 
 void f() {
   _LIBCPP_ASSERT(true, "message"); // expected-error {{'__libcpp_assertion_handler' is unavailable}}
 }

libcxx/test/libcxx/assertions/headers_declare_assertion_handler.sh.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
+//
+//===----------------------------------------------------------------------===//
+
+// Test that all public C++ headers define the assertion handler.
+
+// We flag uses of the assertion handler in older dylibs at compile-time to avoid runtime
+// failures when back-deploying.
+// UNSUPPORTED: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11|12}}
+
+// The system-provided <uchar.h> seems to be broken on AIX, which trips up this test.
+// XFAIL: LIBCXX-AIX-FIXME
+
+/*
+BEGIN-SCRIPT
+
+for i, header in enumerate(public_headers):
+    # Skip C compatibility headers.
+    if header.endswith('.h'):
+        continue
+
+    vars = {
+        'run': 'RUN',
+        'i': i,
+        'restrictions': ' && ' + header_restrictions[header] if header in header_restrictions else '',
+        'header': header
+    }
+
+    print("""\
+// {run}: %{{build}} -DTEST_{i}
+#if defined(TEST_{i}){restrictions}
+#   include <{header}>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+""".format(**vars))
+
+END-SCRIPT
+*/
+
+#include <__config>
+
+// Prevent <ext/hash_map> from generating deprecated warnings for this test.
+#if defined(__DEPRECATED)
+#   undef __DEPRECATED
+#endif
+
+int main(int, char**) { return 0; }
+
+// DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
+// GENERATED-MARKER
+// RUN: %{build} -DTEST_0
+#if defined(TEST_0)
+#   include <algorithm>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_1
+#if defined(TEST_1)
+#   include <any>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_2
+#if defined(TEST_2)
+#   include <array>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_3
+#if defined(TEST_3)
+#   include <atomic>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_4
+#if defined(TEST_4) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <barrier>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_5
+#if defined(TEST_5)
+#   include <bit>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_6
+#if defined(TEST_6)
+#   include <bitset>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_7
+#if defined(TEST_7)
+#   include <cassert>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_8
+#if defined(TEST_8)
+#   include <ccomplex>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_9
+#if defined(TEST_9)
+#   include <cctype>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_10
+#if defined(TEST_10)
+#   include <cerrno>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_11
+#if defined(TEST_11)
+#   include <cfenv>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_12
+#if defined(TEST_12)
+#   include <cfloat>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_13
+#if defined(TEST_13)
+#   include <charconv>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_14
+#if defined(TEST_14)
+#   include <chrono>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_15
+#if defined(TEST_15)
+#   include <cinttypes>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_16
+#if defined(TEST_16)
+#   include <ciso646>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_17
+#if defined(TEST_17)
+#   include <climits>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_18
+#if defined(TEST_18) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <clocale>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_19
+#if defined(TEST_19)
+#   include <cmath>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_20
+#if defined(TEST_20) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <codecvt>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_21
+#if defined(TEST_21)
+#   include <compare>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_22
+#if defined(TEST_22)
+#   include <complex>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_24
+#if defined(TEST_24)
+#   include <concepts>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_25
+#if defined(TEST_25)
+#   include <condition_variable>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_26
+#if defined(TEST_26)
+#   include <coroutine>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_27
+#if defined(TEST_27)
+#   include <csetjmp>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_28
+#if defined(TEST_28)
+#   include <csignal>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_29
+#if defined(TEST_29)
+#   include <cstdarg>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_30
+#if defined(TEST_30)
+#   include <cstdbool>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_31
+#if defined(TEST_31)
+#   include <cstddef>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_32
+#if defined(TEST_32)
+#   include <cstdint>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_33
+#if defined(TEST_33)
+#   include <cstdio>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_34
+#if defined(TEST_34)
+#   include <cstdlib>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_35
+#if defined(TEST_35)
+#   include <cstring>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_36
+#if defined(TEST_36)
+#   include <ctgmath>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_37
+#if defined(TEST_37)
+#   include <ctime>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_39
+#if defined(TEST_39)
+#   include <cuchar>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_40
+#if defined(TEST_40) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#   include <cwchar>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_41
+#if defined(TEST_41) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#   include <cwctype>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_42
+#if defined(TEST_42)
+#   include <deque>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_44
+#if defined(TEST_44)
+#   include <exception>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_45
+#if defined(TEST_45)
+#   include <execution>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_47
+#if defined(TEST_47) && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#   include <filesystem>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_49
+#if defined(TEST_49)
+#   include <format>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_50
+#if defined(TEST_50)
+#   include <forward_list>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_51
+#if defined(TEST_51) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <fstream>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_52
+#if defined(TEST_52)
+#   include <functional>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_53
+#if defined(TEST_53) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <future>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_54
+#if defined(TEST_54)
+#   include <initializer_list>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_56
+#if defined(TEST_56) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <iomanip>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_57
+#if defined(TEST_57) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <ios>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_58
+#if defined(TEST_58)
+#   include <iosfwd>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_59
+#if defined(TEST_59) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <iostream>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_60
+#if defined(TEST_60) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <istream>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_61
+#if defined(TEST_61)
+#   include <iterator>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_62
+#if defined(TEST_62) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <latch>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_63
+#if defined(TEST_63)
+#   include <limits>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_65
+#if defined(TEST_65)
+#   include <list>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_66
+#if defined(TEST_66) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <locale>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_68
+#if defined(TEST_68)
+#   include <map>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_70
+#if defined(TEST_70)
+#   include <memory>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_71
+#if defined(TEST_71) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <mutex>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_72
+#if defined(TEST_72)
+#   include <new>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_73
+#if defined(TEST_73)
+#   include <numbers>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_74
+#if defined(TEST_74)
+#   include <numeric>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_75
+#if defined(TEST_75)
+#   include <optional>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_76
+#if defined(TEST_76) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <ostream>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_77
+#if defined(TEST_77)
+#   include <queue>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_78
+#if defined(TEST_78)
+#   include <random>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_79
+#if defined(TEST_79)
+#   include <ranges>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_80
+#if defined(TEST_80)
+#   include <ratio>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_81
+#if defined(TEST_81) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <regex>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_82
+#if defined(TEST_82)
+#   include <scoped_allocator>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_83
+#if defined(TEST_83) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <semaphore>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_84
+#if defined(TEST_84)
+#   include <set>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_86
+#if defined(TEST_86) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <shared_mutex>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_87
+#if defined(TEST_87)
+#   include <span>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_88
+#if defined(TEST_88) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <sstream>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_89
+#if defined(TEST_89)
+#   include <stack>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_92
+#if defined(TEST_92)
+#   include <stdexcept>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_96
+#if defined(TEST_96) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <streambuf>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_97
+#if defined(TEST_97)
+#   include <string>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_99
+#if defined(TEST_99)
+#   include <string_view>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_100
+#if defined(TEST_100) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <strstream>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_101
+#if defined(TEST_101)
+#   include <system_error>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_103
+#if defined(TEST_103) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <thread>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_104
+#if defined(TEST_104)
+#   include <tuple>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_105
+#if defined(TEST_105)
+#   include <type_traits>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_106
+#if defined(TEST_106)
+#   include <typeindex>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_107
+#if defined(TEST_107)
+#   include <typeinfo>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_109
+#if defined(TEST_109)
+#   include <unordered_map>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_110
+#if defined(TEST_110)
+#   include <unordered_set>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_111
+#if defined(TEST_111)
+#   include <utility>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_112
+#if defined(TEST_112)
+#   include <valarray>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_113
+#if defined(TEST_113)
+#   include <variant>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_114
+#if defined(TEST_114)
+#   include <vector>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_115
+#if defined(TEST_115)
+#   include <version>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_118
+#if defined(TEST_118)
+#   include <experimental/algorithm>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_119
+#if defined(TEST_119) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
+#   include <experimental/coroutine>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_120
+#if defined(TEST_120) && __cplusplus >= 201103L
+#   include <experimental/deque>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_121
+#if defined(TEST_121) && __cplusplus >= 201103L
+#   include <experimental/forward_list>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_122
+#if defined(TEST_122)
+#   include <experimental/functional>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_123
+#if defined(TEST_123)
+#   include <experimental/iterator>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_124
+#if defined(TEST_124) && __cplusplus >= 201103L
+#   include <experimental/list>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_125
+#if defined(TEST_125) && __cplusplus >= 201103L
+#   include <experimental/map>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_126
+#if defined(TEST_126) && __cplusplus >= 201103L
+#   include <experimental/memory_resource>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_127
+#if defined(TEST_127)
+#   include <experimental/propagate_const>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_128
+#if defined(TEST_128) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
+#   include <experimental/regex>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_129
+#if defined(TEST_129) && __cplusplus >= 201103L
+#   include <experimental/set>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_130
+#if defined(TEST_130)
+#   include <experimental/simd>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_131
+#if defined(TEST_131) && __cplusplus >= 201103L
+#   include <experimental/string>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_132
+#if defined(TEST_132)
+#   include <experimental/type_traits>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_133
+#if defined(TEST_133) && __cplusplus >= 201103L
+#   include <experimental/unordered_map>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_134
+#if defined(TEST_134) && __cplusplus >= 201103L
+#   include <experimental/unordered_set>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_135
+#if defined(TEST_135)
+#   include <experimental/utility>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_136
+#if defined(TEST_136) && __cplusplus >= 201103L
+#   include <experimental/vector>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_137
+#if defined(TEST_137)
+#   include <ext/hash_map>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_138
+#if defined(TEST_138)
+#   include <ext/hash_set>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// GENERATED-MARKER

libcxx/utils/CMakeLists.txt

 add_custom_target(libcxx-generate-feature-test-macros
     COMMAND "${Python3_EXECUTABLE}" "${LIBCXX_SOURCE_DIR}/utils/generate_feature_test_macro_components.py"
     COMMENT "Generate the <version> header and tests for feature test macros.")
 
 add_custom_target(libcxx-generate-private-header-tests
     COMMAND "${Python3_EXECUTABLE}" "${LIBCXX_SOURCE_DIR}/utils/generate_private_header_tests.py"
     COMMENT "Generate tests for ensuring that detail headers are private.")
 
+add_custom_target(libcxx-generate-assertion-tests
+    COMMAND "${Python3_EXECUTABLE}" "${LIBCXX_SOURCE_DIR}/utils/generate_assertion_tests.py"
+    COMMENT "Generate tests for inclusion of <__assert>.")
+
 add_custom_target(libcxx-generate-files
     DEPENDS libcxx-generate-public-header-transitive-inclusion-tests
             libcxx-generate-public-header-tests
             libcxx-generate-feature-test-macros
             libcxx-generate-private-header-tests
+            libcxx-generate-assertion-tests
     COMMENT "Create all the auto-generated files in libc++ and its tests.")

libcxx/utils/generate_assertion_tests.py

+#!/usr/bin/env python
+
+import contextlib
+import glob
+import io
+import os
+import pathlib
+import re
+
+header_restrictions = {
+    "barrier": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "future": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "latch": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "semaphore": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "shared_mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "thread": "!defined(_LIBCPP_HAS_NO_THREADS)",
+
+    "filesystem": "!defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)",
+
+    "clocale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "codecvt": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "fstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "iomanip": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "ios": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "iostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "istream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "locale.h": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "locale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "ostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "regex": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "sstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "streambuf": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "strstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+
+    "wctype.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
+    "cwctype": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
+    "cwchar": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
+    "wchar.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
+
+    "experimental/coroutine": "!defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)",
+
+    "experimental/regex": "!defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L",
+    "experimental/deque": "__cplusplus >= 201103L",
+    "experimental/map": "__cplusplus >= 201103L",
+    "experimental/memory_resource": "__cplusplus >= 201103L",
+    "experimental/forward_list": "__cplusplus >= 201103L",
+    "experimental/list": "__cplusplus >= 201103L",
+    "experimental/set": "__cplusplus >= 201103L",
+    "experimental/string": "__cplusplus >= 201103L",
+    "experimental/unordered_map": "__cplusplus >= 201103L",
+    "experimental/unordered_set": "__cplusplus >= 201103L",
+    "experimental/vector": "__cplusplus >= 201103L",
+}
+
+private_headers_still_public_in_modules = [
+    '__assert', '__bsd_locale_defaults.h', '__bsd_locale_fallbacks.h', '__config',
+    '__config_site.in', '__debug', '__hash_table',
+    '__libcpp_version', '__threading_support', '__tree', '__undef_macros'
+]
+
+def find_script(file):
+    """Finds the script used to generate a file inside the file itself. The script is delimited by
+       BEGIN-SCRIPT and END-SCRIPT markers.
+    """
+    with open(file, 'r') as f:
+        content = f.read()
+
+    match = re.search(r'^BEGIN-SCRIPT$(.+)^END-SCRIPT$', content, flags=re.MULTILINE | re.DOTALL)
+    if not match:
+        raise RuntimeError("Was unable to find a script delimited with BEGIN-SCRIPT/END-SCRIPT markers in {}".format(test_file))
+    return match.group(1)
+
+def execute_script(script, variables):
+    """Executes the provided Mako template with the given variables available during the
+       evaluation of the script, and returns the result.
+    """
+    code = compile(script, 'fake-filename', 'exec')
+    output = io.StringIO()
+    with contextlib.redirect_stdout(output):
+        exec(code, variables)
+        output = output.getvalue()
+    return output
+
+def generate_new_file(file, new_content):
+    """Generates the new content of the file by inserting the new content in-between
+       two '// GENERATED-MARKER' markers located in the file.
+    """
+    with open(file, 'r') as f:
+        old_content = f.read()
+
+    try:
+        before, begin_marker, _, end_marker, after = re.split(r'(// GENERATED-MARKER\n)', old_content, flags=re.MULTILINE | re.DOTALL)
+    except ValueError:
+        raise RuntimeError("Failed to split {} based on markers, please make sure the file has exactly two '// GENERATED-MARKER' occurrences".format(file))
+
+    return before + begin_marker + new_content + end_marker + after
+
+def produce(test_file, variables):
+    script = find_script(test_file)
+    result = execute_script(script, variables)
+    new_content = generate_new_file(test_file, result)
+    with open(test_file, 'w', newline='\n') as f:
+        f.write(new_content)
+
+def is_header(file):
+    """Returns whether the given file is a header (i.e. not a directory or the modulemap file)."""
+    return not file.is_dir() and not file.name == 'module.modulemap'
+
+def main():
+    monorepo_root = pathlib.Path(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+    include = pathlib.Path(os.path.join(monorepo_root, 'libcxx', 'include'))
+    test = pathlib.Path(os.path.join(monorepo_root, 'libcxx', 'test'))
+    assert(monorepo_root.exists())
+
+    toplevel_headers     = sorted(str(p.relative_to(include)) for p in include.glob('[a-z]*') if is_header(p))
+    experimental_headers = sorted(str(p.relative_to(include)) for p in include.glob('experimental/[a-z]*') if is_header(p))
+    extended_headers     = sorted(str(p.relative_to(include)) for p in include.glob('ext/[a-z]*') if is_header(p))
+    public_headers       = toplevel_headers + experimental_headers + extended_headers
+    private_headers      = sorted(str(p.relative_to(include)) for p in include.rglob('*') if is_header(p) and str(p.relative_to(include)).startswith('__'))
+    variables = {
+        'toplevel_headers': toplevel_headers,
+        'experimental_headers': experimental_headers,
+        'extended_headers': extended_headers,
+        'public_headers': public_headers,
+        'private_headers': private_headers,
+        'header_restrictions': header_restrictions,
+        'private_headers_still_public_in_modules': private_headers_still_public_in_modules
+    }
+
+    produce(test.joinpath('libcxx/assertions/headers_declare_assertion_handler.sh.cpp'), variables)
+
+
+if __name__ == '__main__':
+    main()

libcxx/utils/generate_feature_test_macro_components.py

 
 /*
   version synopsis
 
 {synopsis}
 
 */
 
+#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 // clang-format off