[libc++] Move everything related solely to _LIBCPP_ASSERT to its own file

[ldionne]

Summary

This is the first step towards disentangling the debug mode and assertions
in libc++. This patch doesn't make any functional change: it simply moves
_LIBCPP_ASSERT-related stuff to its own file so as to make it clear that
libc++ assertions and the debug mode are different things. Future patches
will make it possible to enable assertions without enabling the debug
mode.

[• Quuxplusone]

Seems reasonable to me.

libcxx/include/CMakeLists.txt

102

Are we at all worried about name conflicts? (Or stylistically about adding new top-level detail headers?) Should this be something like __utility/libcpp_assert.h instead?
OTOH, maybe we keep it like this right now, and then at some point in the future we move __assert to __foo/libcpp_assert.h and __debug to __foo/debug_iterators.h in the same commit, for some value of __foo on which I'm sure we'll disagree. :)

libcxx/include/__debug

27

This < allows people to set -D_LIBCPP_DEBUG_LEVEL=-1 without triggering the #error on line 32.

libcxx/src/assert.cpp

19

Consider std::to_string(__line_) for consistency with std::fprintf and std::abort on lines 27-28.

[philnik]

libcxx/include/CMakeLists.txt

102

I'm definitely in favor of moving that stuff into some directory. Maybe __libcpp/? That would most likely not clash with any new C++ headers and we could leave the libcpp_ prefix out.

libcxx/include/__debug

27

_LIBCPP_DEBUG_LEVEL should never be set directly. The public interface is _LIBCPP_DEBUG.

[• Quuxplusone]

libcxx/include/CMakeLists.txt

102

and we could leave the libcpp_ prefix out.

I don't want to get into a situation where <assert.h> means one thing and "./assert.h" means a different thing, so the prefix would need to stay even in that case. (Likewise, if we ever granularize <string>, I'll oppose the creation of __string/string.h. But luckily in that case it'll be __string/basic_string.h so the issue won't arise.)

[ldionne]

libcxx/include/CMakeLists.txt

102

I agree that we should move those to a subdirectory, however I want to do that separately to give us ample time to bikeshed the name.

We already have a "pattern" for adding these detail headers right now: it's to add them at the top-level. So I'm following the trend in this patch for the time being.

libcxx/include/__debug

27

I agree with Arthur, I'll fix it. This is an easy way to ensure that users don't define things they shouldn't define.

[ldionne]

Rebase and fix a couple of issues

[ldionne]

Rebase again and hopefully fix all CI issues. I'm going to land this if CI is green.

libcxx/include/CMakeLists.txt

set(files
   __algorithm/stable_partition.h
   __algorithm/stable_sort.h
   __algorithm/swap_ranges.h
   __algorithm/transform.h
   __algorithm/unique.h
   __algorithm/unique_copy.h
   __algorithm/unwrap_iter.h
   __algorithm/upper_bound.h
+  __assert
   __availability
   __bit/bit_cast.h
   __bit/byteswap.h
   __bit_reference
   __bits
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __charconv/chars_format.h

libcxx/include/__algorithm/clamp.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_CLAMP_H
 #define _LIBCPP___ALGORITHM_CLAMP_H
 
 #include <__algorithm/comp.h>
+#include <__assert>
 #include <__config>
-#include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14

libcxx/include/__algorithm/comp_ref_type.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_COMP_REF_TYPE_H
 #define _LIBCPP___ALGORITHM_COMP_REF_TYPE_H
 
+#include <__assert>
 #include <__config>
 #include <__debug>
 #include <__utility/declval.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__algorithm/sample.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_SAMPLE_H
 #define _LIBCPP___ALGORITHM_SAMPLE_H
 
 #include <__algorithm/min.h>
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__random/uniform_int_distribution.h>
 #include <iterator>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__assert

+// -*- 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___ASSERT
+#define _LIBCPP___ASSERT
+
+#include <__config>
+#include <iosfwd> // for std::string
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_DEBUG_LEVEL >= 1
+#   define _LIBCPP_ASSERT_IMPL(x, m) ((x) ? (void)0 : ::std::__libcpp_debug_function(::std::__libcpp_debug_info(__FILE__, __LINE__, #x, m)))
+#else
+#   define _LIBCPP_ASSERT_IMPL(x, m) ((void)0)
+#endif
+
+// We do this dance because some of our tests re-define _LIBCPP_ASSERT to something else.
+// In the future, we should find other ways to test our assertions and disallow re-defining
+// _LIBCPP_ASSERT.
+#if !defined(_LIBCPP_ASSERT)
+#   define _LIBCPP_ASSERT(x, m) _LIBCPP_ASSERT_IMPL(x, m)
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct _LIBCPP_TEMPLATE_VIS __libcpp_debug_info {
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+  __libcpp_debug_info()
+      : __file_(nullptr), __line_(-1), __pred_(nullptr), __msg_(nullptr) {}
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+  __libcpp_debug_info(const char* __f, int __l, const char* __p, const char* __m)
+    : __file_(__f), __line_(__l), __pred_(__p), __msg_(__m) {}
+
+  _LIBCPP_FUNC_VIS string what() const;
+
+  const char* __file_;
+  int __line_;
+  const char* __pred_;
+  const char* __msg_;
+};
+
+/// __libcpp_debug_function_type - The type of the assertion failure handler.
+typedef void(*__libcpp_debug_function_type)(__libcpp_debug_info const&);
+
+/// __libcpp_debug_function - The handler function called when a _LIBCPP_ASSERT
+///    fails.
+extern _LIBCPP_EXPORTED_FROM_ABI __libcpp_debug_function_type __libcpp_debug_function;
+
+/// __libcpp_abort_debug_function - A debug handler that aborts when called.
+_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
+void __libcpp_abort_debug_function(__libcpp_debug_info const&);
+
+/// __libcpp_set_debug_function - Set the debug handler to the specified
+///    function.
+_LIBCPP_FUNC_VIS
+bool __libcpp_set_debug_function(__libcpp_debug_function_type __func);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ASSERT

libcxx/include/__coroutine/coroutine_handle.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___COROUTINE_COROUTINE_HANDLE_H
 #define _LIBCPP___COROUTINE_COROUTINE_HANDLE_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__functional/hash.h>
 #include <__memory/addressof.h>
 #include <compare>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__debug

 #endif
 
 #if _LIBCPP_DEBUG_LEVEL >= 1 || defined(_LIBCPP_BUILDING_LIBRARY)
 #   include <cstddef>
 #   include <cstdio>
 #   include <cstdlib>
 #endif
 
-#if _LIBCPP_DEBUG_LEVEL == 0
+#if _LIBCPP_DEBUG_LEVEL < 2
 #   define _LIBCPP_DEBUG_ASSERT(x, m) ((void)0)
-#   define _LIBCPP_ASSERT_IMPL(x, m) ((void)0)
-#elif _LIBCPP_DEBUG_LEVEL == 1
-#   define _LIBCPP_DEBUG_ASSERT(x, m) ((void)0)
-#   define _LIBCPP_ASSERT_IMPL(x, m) ((x) ? (void)0 : ::std::__libcpp_debug_function(::std::__libcpp_debug_info(__FILE__, __LINE__, #x, m)))
 #elif _LIBCPP_DEBUG_LEVEL == 2
 #   define _LIBCPP_DEBUG_ASSERT(x, m) _LIBCPP_ASSERT(::std::__libcpp_is_constant_evaluated() || (x), m)
-#   define _LIBCPP_ASSERT_IMPL(x, m) ((x) ? (void)0 : ::std::__libcpp_debug_function(::std::__libcpp_debug_info(__FILE__, __LINE__, #x, m)))
 #else
 #   error _LIBCPP_DEBUG_LEVEL must be one of 0, 1, 2
 #endif
 
-#if !defined(_LIBCPP_ASSERT)
-#   define _LIBCPP_ASSERT(x, m) _LIBCPP_ASSERT_IMPL(x, m)
-#endif
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_TEMPLATE_VIS __libcpp_debug_info {
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-  __libcpp_debug_info()
-      : __file_(nullptr), __line_(-1), __pred_(nullptr), __msg_(nullptr) {}
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-  __libcpp_debug_info(const char* __f, int __l, const char* __p, const char* __m)
-    : __file_(__f), __line_(__l), __pred_(__p), __msg_(__m) {}
-
-  _LIBCPP_FUNC_VIS string what() const;
-
-  const char* __file_;
-  int __line_;
-  const char* __pred_;
-  const char* __msg_;
-};
-
-/// __libcpp_debug_function_type - The type of the assertion failure handler.
-typedef void(*__libcpp_debug_function_type)(__libcpp_debug_info const&);
-
-/// __libcpp_debug_function - The handler function called when a _LIBCPP_ASSERT
-///    fails.
-extern _LIBCPP_EXPORTED_FROM_ABI __libcpp_debug_function_type __libcpp_debug_function;
-
-/// __libcpp_abort_debug_function - A debug handler that aborts when called.
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
-void __libcpp_abort_debug_function(__libcpp_debug_info const&);
-
-/// __libcpp_set_debug_function - Set the debug handler to the specified
-///    function.
-_LIBCPP_FUNC_VIS
-bool __libcpp_set_debug_function(__libcpp_debug_function_type __func);
-
 #if _LIBCPP_DEBUG_LEVEL == 2 || defined(_LIBCPP_BUILDING_LIBRARY)
 
 struct _LIBCPP_TYPE_VIS __c_node;
 
 struct _LIBCPP_TYPE_VIS __i_node
 {
     void* __i_;
     __i_node* __next_;

libcxx/include/__filesystem/directory_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H
 #define _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H
 
+#include <__assert>
 #include <__availability>
 #include <__config>
-#include <__debug>
 #include <__filesystem/directory_entry.h>
 #include <__filesystem/directory_options.h>
 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <cstddef>

libcxx/include/__filesystem/path_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FILESYSTEM_PATH_ITERATOR_H
 #define _LIBCPP___FILESYSTEM_PATH_ITERATOR_H
 
+#include <__assert>
 #include <__availability>
 #include <__config>
-#include <__debug>
 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
 #include <cstddef>
 #include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__format/format_arg.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMAT_ARG_H
 #define _LIBCPP___FORMAT_FORMAT_ARG_H
 
+#include <__assert>
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
 #include <__memory/addressof.h>
 #include <__utility/unreachable.h>
 #include <__variant/monostate.h>

libcxx/include/__format/format_string.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMAT_STRING_H
 #define _LIBCPP___FORMAT_FORMAT_STRING_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__format/format_error.h>
 #include <cstddef>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/include/__format/formatter.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMATTER_H
 #define _LIBCPP___FORMAT_FORMATTER_H
 
 #include <__algorithm/copy.h>
 #include <__algorithm/fill_n.h>
+#include <__assert>
 #include <__availability>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/parser_std_format_spec.h>
 #include <__utility/unreachable.h>
 #include <string_view>

libcxx/include/__format/formatter_floating_point.h

 
 #include <__algorithm/copy.h>
 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/find.h>
 #include <__algorithm/min.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/transform.h>
+#include <__assert>
 #include <__concepts/arithmetic.h>
 #include <__config>
-#include <__debug>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/parser_std_format_spec.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>

libcxx/include/__format/formatter_integral.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H
 #define _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H
 
 #include <__algorithm/copy.h>
 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/transform.h>
+#include <__assert>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/formatter.h>
 #include <__format/parser_std_format_spec.h>
 #include <__utility/unreachable.h>
 #include <array>
 #include <charconv>

libcxx/include/__format/formatter_pointer.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMATTER_POINTER_H
 #define _LIBCPP___FORMAT_FORMATTER_POINTER_H
 
 #include <__algorithm/copy.h>
+#include <__assert>
 #include <__availability>
 #include <__config>
-#include <__debug>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/parser_std_format_spec.h>
 #include <__iterator/access.h>
 #include <cstdint>
 

libcxx/include/__format/formatter_string.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMATTER_STRING_H
 #define _LIBCPP___FORMAT_FORMATTER_STRING_H
 
+#include <__assert>
 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_string.h>
 #include <__format/formatter.h>
 #include <__format/parser_std_format_spec.h>
 #include <string_view>
 

libcxx/include/__format/parser_std_format_spec.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H
 #define _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H
 
 #include <__algorithm/find_if.h>
 #include <__algorithm/min.h>
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_error.h>
 #include <__format/format_string.h>
 #include <__variant/monostate.h>
 #include <bit>
 #include <concepts>
 #include <cstdint>
 #include <type_traits>

libcxx/include/__functional/function.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___FUNCTIONAL_FUNCTION_H
 #define _LIBCPP___FUNCTIONAL_FUNCTION_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__functional/binary_function.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/shared_ptr.h>

libcxx/include/__hash_table

 // -*- 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__HASH_TABLE
 #define _LIBCPP__HASH_TABLE
 
+#include <__assert>
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <algorithm>
 #include <cmath>
 #include <initializer_list>
 #include <iterator>
 #include <memory>

libcxx/include/__iterator/advance.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___ITERATOR_ADVANCE_H
 #define _LIBCPP___ITERATOR_ADVANCE_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <concepts>
 #include <cstdlib>
 #include <limits>

libcxx/include/__iterator/common_iterator.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___ITERATOR_COMMON_ITERATOR_H
 #define _LIBCPP___ITERATOR_COMMON_ITERATOR_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <concepts>
 #include <variant>

libcxx/include/__iterator/counted_iterator.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___ITERATOR_COUNTED_ITERATOR_H
 #define _LIBCPP___ITERATOR_COUNTED_ITERATOR_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iter_swap.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/pointer_traits.h>

libcxx/include/__iterator/next.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___ITERATOR_NEXT_H
 #define _LIBCPP___ITERATOR_NEXT_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__iterator/prev.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___ITERATOR_PREV_H
 #define _LIBCPP___ITERATOR_PREV_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__memory/construct_at.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___MEMORY_CONSTRUCT_AT_H
 #define _LIBCPP___MEMORY_CONSTRUCT_AT_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/access.h>
 #include <__memory/addressof.h>
 #include <__memory/voidify.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__node_handle

public:
 
   friend void swap(node-handle& x, node-handle& y) noexcept(noexcept(x.swap(y))) {
     x.swap(y);
   }
 };
 
 */
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <memory>
 #include <optional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__numeric/gcd_lcm.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___NUMERIC_GCD_LCM_H
 #define _LIBCPP___NUMERIC_GCD_LCM_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__ranges/drop_view.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___RANGES_DROP_VIEW_H
 #define _LIBCPP___RANGES_DROP_VIEW_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/non_propagating_cache.h>

libcxx/include/__ranges/iota_view.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___RANGES_IOTA_VIEW_H
 #define _LIBCPP___RANGES_IOTA_VIEW_H
 
+#include <__assert>
 #include <__compare/three_way_comparable.h>
 #include <__concepts/arithmetic.h>
 #include <__concepts/constructible.h>
 #include <__concepts/convertible_to.h>
 #include <__concepts/copyable.h>
 #include <__concepts/equality_comparable.h>
 #include <__concepts/invocable.h>
 #include <__concepts/same_as.h>
 #include <__concepts/semiregular.h>
 #include <__concepts/totally_ordered.h>
 #include <__config>
-#include <__debug>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/unreachable_sentinel.h>
 #include <__ranges/copyable_box.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/view_interface.h>

libcxx/include/__ranges/subrange.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___RANGES_SUBRANGE_H
 #define _LIBCPP___RANGES_SUBRANGE_H
 
+#include <__assert>
 #include <__concepts/constructible.h>
 #include <__concepts/convertible_to.h>
 #include <__concepts/copyable.h>
 #include <__concepts/derived_from.h>
 #include <__concepts/different_from.h>
 #include <__config>
-#include <__debug>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/enable_borrowed_range.h>

libcxx/include/__ranges/view_interface.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___RANGES_VIEW_INTERFACE_H
 #define _LIBCPP___RANGES_VIEW_INTERFACE_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/prev.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty.h>
 #include <concepts>

libcxx/include/__string

 
 #include <__algorithm/copy.h>
 #include <__algorithm/copy_backward.h>
 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/find_end.h>
 #include <__algorithm/find_first_of.h>
 #include <__algorithm/min.h>
+#include <__assert>
 #include <__config>
+#include <__debug>
 #include <__functional/hash.h>     // for __murmur2_or_cityhash
 #include <__iterator/iterator_traits.h>
 #include <cstdint>     // for uint_least16_t
 #include <cstdio>      // for EOF
 #include <cstring>     // for memcpy
 #include <iosfwd>      // for streampos & friends
 #include <type_traits> // for __libcpp_is_constant_evaluated
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #   include <cwchar> // for wmemcpy
 #endif
 
-#include <__debug>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

libcxx/include/array

 template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept;   // constexpr in C++14
 template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept;             // constexpr in C++14
 template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__tuple>
 #include <__utility/unreachable.h>
 #include <algorithm>
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
 #include <version>

libcxx/include/bit

enum class endian {
     big = see below,           // C++20
     native = see below         // C++20
   };
 
 } // namespace std
 
 */
 
+#include <__assert>
 #include <__bit/bit_cast.h>
 #include <__bit/byteswap.h>
 #include <__bits> // __libcpp_clz
 #include <__config>
-#include <__debug>
 #include <limits>
 #include <type_traits>
 #include <version>
 
 #if defined(__IBMCPP__)
 #include "__support/ibm/support.h"
 #endif
 #if defined(_LIBCPP_COMPILER_MSVC)

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 <__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/deque

 template <class T, class Allocator, class Predicate>
     typename deque<T, Allocator>::size_type
     erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/iterator_traits.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <compare>
 #include <initializer_list>
 #include <iterator>
 #include <limits>

libcxx/include/experimental/coroutine

 template <class P> struct hash<coroutine_handle<P>>;
 
 } // namespace coroutines_v1
 } // namespace experimental
 } // namespace std
 
  */
 
-#include <__debug>
+#include <__assert>
 #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/memory_resource

 
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
-#include <__debug>
+#include <__assert>
 #include <__tuple>
 #include <cstddef>
 #include <cstdlib>
 #include <experimental/__config>
 #include <experimental/__memory>
 #include <limits>
 #include <memory>
 #include <new>

libcxx/include/fstream

 
 typedef basic_fstream<char>    fstream;
 typedef basic_fstream<wchar_t> wfstream;
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__availability>
 #include <__config>
-#include <__debug>
 #include <__locale>
 #include <__utility/unreachable.h>
 #include <cstdio>
 #include <cstdlib>
 #include <istream>
 #include <ostream>
 #include <version>
 

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 <__availability>
 #include <__config>
-#include <__debug>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <chrono>
 #include <exception>
 #include <memory>
 #include <mutex>

libcxx/include/list

 template <class T, class Allocator, class Predicate>
     typename list<T, Allocator>::size_type
     erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__config>
 #include <__debug>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>

libcxx/include/locale

 class messages_base;
 template <class charT> class messages;
 template <class charT> class messages_byname;
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__config>
 #include <__debug>
 #include <__locale>
 #include <algorithm>
 #ifndef __APPLE__
 # include <cstdarg>
 #endif
 #include <cstdio>

libcxx/include/map

 template <class Key, class T, class Compare, class Allocator, class Predicate>
 typename multimap<Key, T, Compare, Allocator>::size_type
 erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>

libcxx/include/module.modulemap

module std [system] {
   }
   module version {
     header "version"
     export *
   }
 
   // __config not modularised due to a bug in Clang
   // FIXME: These should be private.
+  module __assert            { private header "__assert"            export * }
   module __availability      { private header "__availability"      export * }
   module __bit_reference     { private header "__bit_reference"     export * }
   module __bits              { private header "__bits"              export * }
   module __debug             {         header "__debug"             export * }
   module __errc              { private header "__errc"              export * }
   module __hash_table        {         header "__hash_table"        export * }
   module __locale            { private header "__locale"            export * }
   module __mbstate_t         { private header "__mbstate_t.h"       export * }

libcxx/include/optional

 
 template<class T>
   optional(T) -> optional<T>;
 
 } // namespace std
 
 */
 
+#include <__assert>
 #include <__availability>
 #include <__concepts/invocable.h>
 #include <__config>
-#include <__debug>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
 #include <version>

libcxx/include/regex

 typedef regex_token_iterator<const char*>             cregex_token_iterator;
 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 <__assert>
 #include <__config>
-#include <__debug>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
 #include <compare>
 #include <deque>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <stdexcept>

libcxx/include/set

 template <class Key, class Compare, class Allocator, class Predicate>
 typename multiset<Key, Compare, Allocator>::size_type
 erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>

libcxx/include/span

 
 template<class R>
     span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
 
 } // namespace std
 
 */
 
+#include <__assert>
 #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/string

 basic_string<char8_t>  operator "" s( const char8_t *str,  size_t len ); // C++20
 basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
 basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__config>
 #include <__debug>
 #include <__ios/fpos.h>
 #include <__iterator/wrap_iter.h>
 #include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstdlib>

libcxx/include/string_view

namespace std {
   constexpr basic_string_view<char16_t> operator "" sv( const char16_t *str, size_t len ) noexcept;
   constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
 
 */
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #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 <algorithm>
 #include <compare>

libcxx/include/thread

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

libcxx/include/unordered_map

template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 }  // std
 
 */
 
+#include <__assert>
 #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 <__assert>
 #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/vector

 template <class T, class Allocator, class Predicate>
 typename vector<T, Allocator>::size_type
 erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
+#include <__assert>
 #include <__bit_reference>
 #include <__config>
 #include <__debug>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <algorithm>

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   utility.cpp
   valarray.cpp
   variant.cpp
   vector.cpp
   )
 
 if (LIBCXX_ENABLE_DEBUG_MODE_SUPPORT)
   list(APPEND LIBCXX_SOURCES
+    assert.cpp
     debug.cpp
     )
 endif()
 
 if (LIBCXX_ENABLE_RANDOM_DEVICE)
   list(APPEND LIBCXX_SOURCES
     random.cpp
     )

libcxx/src/assert.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__assert>
+#include <__config>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+std::string __libcpp_debug_info::what() const {
+  string msg = __file_;
+  msg += ":" + to_string(__line_) + ": _LIBCPP_ASSERT '";
+  msg += __pred_;
+  msg += "' failed. ";
+  msg += __msg_;
+  return msg;
+}
+
+_LIBCPP_NORETURN void __libcpp_abort_debug_function(__libcpp_debug_info const& info) {
+    std::fprintf(stderr, "%s\n", info.what().c_str());
+    std::abort();
+}
+
+_LIBCPP_SAFE_STATIC __libcpp_debug_function_type
+    __libcpp_debug_function = __libcpp_abort_debug_function;
+
+bool __libcpp_set_debug_function(__libcpp_debug_function_type __func) {
+  __libcpp_debug_function = __func;
+  return true;
+}
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/src/debug.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "__assert"
 #include "__config"
 #include "__debug"
 #include "functional"
 #include "algorithm"
 #include "string"
 #include "cstdio"
 #include "__hash_table"
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include "mutex"
 #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #pragma comment(lib, "pthread")
 #endif
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-std::string __libcpp_debug_info::what() const {
-  string msg = __file_;
-  msg += ":" + to_string(__line_) + ": _LIBCPP_ASSERT '";
-  msg += __pred_;
-  msg += "' failed. ";
-  msg += __msg_;
-  return msg;
-}
-_LIBCPP_NORETURN void __libcpp_abort_debug_function(__libcpp_debug_info const& info) {
-    std::fprintf(stderr, "%s\n", info.what().c_str());
-    std::abort();
-}
-
-_LIBCPP_SAFE_STATIC __libcpp_debug_function_type
-    __libcpp_debug_function = __libcpp_abort_debug_function;
-
-bool __libcpp_set_debug_function(__libcpp_debug_function_type __func) {
-  __libcpp_debug_function = __func;
-  return true;
-}
-
 _LIBCPP_FUNC_VIS
 __libcpp_db*
 __get_db()
 {
     static _LIBCPP_NO_DESTROY __libcpp_db db;
     return &db;
 }
 

libcxx/src/filesystem/directory_iterator.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__assert>
 #include "__config"
 #include "filesystem"
 #include "stack"
 #include <errno.h>
 
 #include "filesystem_common.h"
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM

libcxx/src/filesystem/filesystem_common.h

 //===----------------------------------------------------------------------===////
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===////
 
 #ifndef FILESYSTEM_COMMON_H
 #define FILESYSTEM_COMMON_H
 
+#include <__assert>
 #include "__config"
 #include "array"
 #include "chrono"
 #include "climits"
 #include "cstdarg"
 #include "ctime"
 #include "filesystem"
 #include "ratio"

libcxx/src/filesystem/operations.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__assert>
 #include <__utility/unreachable.h>
 #include "filesystem"
 #include "array"
 #include "iterator"
 #include "string_view"
 #include "type_traits"
 #include "vector"
 #include "cstdlib"

libcxx/src/filesystem/posix_compat.h

 // These are provided within an anonymous namespace within the detail
 // namespace - callers need to include this header and call them as
 // detail::function(), regardless of platform.
 //
 
 #ifndef POSIX_COMPAT_H
 #define POSIX_COMPAT_H
 
+#include <__assert>
 #include "filesystem"
 
 #include "filesystem_common.h"
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>

libcxx/src/include/ryu/common.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
 #define _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
+#include <__assert>
 #include "__config"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __decimalLength9(const uint32_t __v) {
   // Function precondition: __v is not a 10-digit number.
   // (f2s: 9 digits are sufficient for round-tripping.)
   // (d2fixed: We print 9-digit blocks.)

libcxx/src/include/ryu/d2s_intrinsics.h

 // DEALINGS IN THE SOFTWARE.
 
 #ifndef _LIBCPP_SRC_INCLUDE_RYU_DS2_INTRINSICS_H
 #define _LIBCPP_SRC_INCLUDE_RYU_DS2_INTRINSICS_H
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
+#include <__assert>
 #include "__config"
 
 #include "include/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(_M_X64) && defined(_MSC_VER)
 #define _LIBCPP_INTRINSIC128 1

libcxx/src/include/to_chars_floating_point.h

 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
 #include "__algorithm/find.h"
 #include "__algorithm/find_if.h"
 #include "__algorithm/lower_bound.h"
 #include "__algorithm/min.h"
+#include <__assert>
 #include "__config"
 #include "__iterator/access.h"
 #include "__iterator/size.h"
 #include "bit"
 #include "cfloat"
 #include "climits"
 #include "include/ryu/ryu.h"
 

libcxx/src/mutex.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__assert>
 #include "mutex"
 #include "limits"
 #include "system_error"
 #include "include/atomic_support.h"
 #include "__undef_macros"
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)

libcxx/src/ryu/d2fixed.cpp

 // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
+#include <__assert>
 #include "__config"
 #include "charconv"
 #include "cstring"
 #include "system_error"
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2fixed_full_table.h"

libcxx/src/ryu/d2s.cpp

 // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
+#include <__assert>
 #include "__config"
 #include "charconv"
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2s.h"
 #include "include/ryu/d2s_full_table.h"
 #include "include/ryu/d2s_intrinsics.h"

libcxx/src/ryu/f2s.cpp

 // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
 // Avoid formatting to keep the changes with the original code minimal.
 // clang-format off
 
+#include <__assert>
 #include "__config"
 #include "charconv"
 
 #include "include/ryu/common.h"
 #include "include/ryu/d2fixed.h"
 #include "include/ryu/d2s_intrinsics.h"
 #include "include/ryu/digit_table.h"
 #include "include/ryu/f2s.h"

libcxx/src/string.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__assert>
 #include "string"
 #include "charconv"
 #include "cstdlib"
 #include "cerrno"
 #include "limits"
 #include "stdexcept"
 #include <stdio.h>
-#include "__debug"
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #   include "cwchar"
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON

libcxx/src/strstream.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__assert>
 #include <__utility/unreachable.h>
 #include "strstream"
 #include "algorithm"
 #include "climits"
 #include "cstring"
 #include "cstdlib"
-#include "__debug"
 #include "__undef_macros"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 strstreambuf::strstreambuf(streamsize __alsize)
     : __strmode_(__dynamic),
       __alsize_(__alsize),
       __palloc_(nullptr),

libcxx/src/support/ibm/xlocale_zos.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <__assert>
 #include <__support/ibm/xlocale.h>
 #include <sstream>
 #include <vector>
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 

libcxx/src/system_error.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "__config"
 
 #include "system_error"
 
+#include <__assert>
 #include "include/config_elast.h"
 #include "cerrno"
 #include "cstring"
 #include "cstdio"
 #include "cstdlib"
 #include "string"
 #include "string.h"
-#include "__debug"
 
 #if defined(__ANDROID__)
 #include <android/api-level.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // class error_category

libcxx/test/libcxx/diagnostics/detail.headers/assert.module.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__assert'}}
+#include <__assert>