[libc++] Format the code base (#74334)

This patch runs clang-format on all of libcxx/include and libcxx/src, in
accordance with the RFC discussed at [1]. Follow-up patches will format
the benchmarks, the test suite and remaining parts of the code. I'm
splitting this one into its own patch so the diff is a bit easier to
review.

This patch was generated with:

   find libcxx/include libcxx/src -type f \
      | grep -v 'module.modulemap.in' \
      | grep -v 'CMakeLists.txt' \
      | grep -v 'README.txt' \
      | grep -v 'libcxx.imp' \
      | grep -v '__config_site.in' \
      | xargs clang-format -i

A Git merge driver is available in libcxx/utils/clang-format-merge-driver.sh
to help resolve merge and rebase issues across these formatting changes.

[1]: https://discourse.llvm.org/t/rfc-clang-formatting-all-of-libc-once-and-for-all

1 files changed, 84 insertions, 141 deletions

diff --git a/libcxx/src/system_error.cpp b/libcxx/src/system_error.cpp
index 1cc6b7d..034b73c 100644
--- a/libcxx/src/system_error.cpp
+++ b/libcxx/src/system_error.cpp
@@ -13,14 +13,14 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <string>
 #include <string.h>
+#include <string>
 #include <system_error>
 
 #include "include/config_elast.h"
 
 #if defined(__ANDROID__)
-#include <android/api-level.h>
+#  include <android/api-level.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -33,7 +33,7 @@ constexpr size_t strerror_buff_size = 1024;
 
 string do_strerror_r(int ev);
 
-#if defined(_LIBCPP_MSVCRT_LIKE)
+#  if defined(_LIBCPP_MSVCRT_LIKE)
 string do_strerror_r(int ev) {
   char buffer[strerror_buff_size];
   if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
@@ -41,14 +41,13 @@ string do_strerror_r(int ev) {
   std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
   return string(buffer);
 }
-#else
+#  else
 
 // Only one of the two following functions will be used, depending on
 // the return type of strerror_r:
 
 // For the GNU variant, a char* return value:
-__attribute__((unused)) const char *
-handle_strerror_r_return(char *strerror_return, char *buffer) {
+__attribute__((unused)) const char* handle_strerror_r_return(char* strerror_return, char* buffer) {
   // GNU always returns a string pointer in its return value. The
   // string might point to either the input buffer, or a static
   // buffer, but we don't care which.
@@ -56,8 +55,7 @@ handle_strerror_r_return(char *strerror_return, char *buffer) {
 }
 
 // For the POSIX variant: an int return value.
-__attribute__((unused)) const char *
-handle_strerror_r_return(int strerror_return, char *buffer) {
+__attribute__((unused)) const char* handle_strerror_r_return(int strerror_return, char* buffer) {
   // The POSIX variant either:
   // - fills in the provided buffer and returns 0
   // - returns a positive error value, or
@@ -79,201 +77,146 @@ handle_strerror_r_return(int strerror_return, char *buffer) {
 // This function handles both GNU and POSIX variants, dispatching to
 // one of the two above functions.
 string do_strerror_r(int ev) {
-    char buffer[strerror_buff_size];
-    // Preserve errno around the call. (The C++ standard requires that
-    // system_error functions not modify errno).
-    const int old_errno = errno;
-    const char *error_message = handle_strerror_r_return(
-        ::strerror_r(ev, buffer, strerror_buff_size), buffer);
-    // If we didn't get any message, print one now.
-    if (!error_message[0]) {
-      std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
-      error_message = buffer;
-    }
-    errno = old_errno;
-    return string(error_message);
-}
-#endif
+  char buffer[strerror_buff_size];
+  // Preserve errno around the call. (The C++ standard requires that
+  // system_error functions not modify errno).
+  const int old_errno       = errno;
+  const char* error_message = handle_strerror_r_return(::strerror_r(ev, buffer, strerror_buff_size), buffer);
+  // If we didn't get any message, print one now.
+  if (!error_message[0]) {
+    std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
+    error_message = buffer;
+  }
+  errno = old_errno;
+  return string(error_message);
+}
+#  endif
 
 #endif // !defined(_LIBCPP_HAS_NO_THREADS)
 
 string make_error_str(const error_code& ec, string what_arg) {
-    if (ec) {
-        if (!what_arg.empty()) {
-            what_arg += ": ";
-        }
-        what_arg += ec.message();
+  if (ec) {
+    if (!what_arg.empty()) {
+      what_arg += ": ";
     }
-    return what_arg;
+    what_arg += ec.message();
+  }
+  return what_arg;
 }
 
 string make_error_str(const error_code& ec) {
-    if (ec) {
-        return ec.message();
-    }
-    return string();
+  if (ec) {
+    return ec.message();
+  }
+  return string();
 }
 } // end namespace
 
-string
-__do_message::message(int ev) const
-{
+string __do_message::message(int ev) const {
 #if defined(_LIBCPP_HAS_NO_THREADS)
-    return string(::strerror(ev));
+  return string(::strerror(ev));
 #else
-    return do_strerror_r(ev);
+  return do_strerror_r(ev);
 #endif
 }
 
-class _LIBCPP_HIDDEN __generic_error_category
-    : public __do_message
-{
+class _LIBCPP_HIDDEN __generic_error_category : public __do_message {
 public:
-    virtual const char* name() const noexcept;
-    virtual string message(int ev) const;
+  virtual const char* name() const noexcept;
+  virtual string message(int ev) const;
 };
 
-const char*
-__generic_error_category::name() const noexcept
-{
-    return "generic";
-}
+const char* __generic_error_category::name() const noexcept { return "generic"; }
 
-string
-__generic_error_category::message(int ev) const
-{
+string __generic_error_category::message(int ev) const {
 #ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified generic_category error");
+  if (ev > _LIBCPP_ELAST)
+    return string("unspecified generic_category error");
 #endif // _LIBCPP_ELAST
-    return __do_message::message(ev);
+  return __do_message::message(ev);
 }
 
-const error_category&
-generic_category() noexcept
-{
-    union AvoidDestroyingGenericCategory {
-        __generic_error_category generic_error_category;
-        constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {}
-        ~AvoidDestroyingGenericCategory() {}
-    };
-    constinit static AvoidDestroyingGenericCategory helper;
-    return helper.generic_error_category;
+const error_category& generic_category() noexcept {
+  union AvoidDestroyingGenericCategory {
+    __generic_error_category generic_error_category;
+    constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {}
+    ~AvoidDestroyingGenericCategory() {}
+  };
+  constinit static AvoidDestroyingGenericCategory helper;
+  return helper.generic_error_category;
 }
 
-class _LIBCPP_HIDDEN __system_error_category
-    : public __do_message
-{
+class _LIBCPP_HIDDEN __system_error_category : public __do_message {
 public:
-    virtual const char* name() const noexcept;
-    virtual string message(int ev) const;
-    virtual error_condition default_error_condition(int ev) const noexcept;
+  virtual const char* name() const noexcept;
+  virtual string message(int ev) const;
+  virtual error_condition default_error_condition(int ev) const noexcept;
 };
 
-const char*
-__system_error_category::name() const noexcept
-{
-    return "system";
-}
+const char* __system_error_category::name() const noexcept { return "system"; }
 
-string
-__system_error_category::message(int ev) const
-{
+string __system_error_category::message(int ev) const {
 #ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified system_category error");
+  if (ev > _LIBCPP_ELAST)
+    return string("unspecified system_category error");
 #endif // _LIBCPP_ELAST
-    return __do_message::message(ev);
+  return __do_message::message(ev);
 }
 
-error_condition
-__system_error_category::default_error_condition(int ev) const noexcept
-{
+error_condition __system_error_category::default_error_condition(int ev) const noexcept {
 #ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return error_condition(ev, system_category());
+  if (ev > _LIBCPP_ELAST)
+    return error_condition(ev, system_category());
 #endif // _LIBCPP_ELAST
-    return error_condition(ev, generic_category());
+  return error_condition(ev, generic_category());
 }
 
-const error_category&
-system_category() noexcept
-{
-    union AvoidDestroyingSystemCategory {
-        __system_error_category system_error_category;
-        constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {}
-        ~AvoidDestroyingSystemCategory() {}
-    };
-    constinit static AvoidDestroyingSystemCategory helper;
-    return helper.system_error_category;
+const error_category& system_category() noexcept {
+  union AvoidDestroyingSystemCategory {
+    __system_error_category system_error_category;
+    constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {}
+    ~AvoidDestroyingSystemCategory() {}
+  };
+  constinit static AvoidDestroyingSystemCategory helper;
+  return helper.system_error_category;
 }
 
 // error_condition
 
-string
-error_condition::message() const
-{
-    return __cat_->message(__val_);
-}
+string error_condition::message() const { return __cat_->message(__val_); }
 
 // error_code
 
-string
-error_code::message() const
-{
-    return __cat_->message(__val_);
-}
+string error_code::message() const { return __cat_->message(__val_); }
 
 // system_error
 
 system_error::system_error(error_code ec, const string& what_arg)
-    : runtime_error(make_error_str(ec, what_arg)),
-      __ec_(ec)
-{
-}
+    : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
 
 system_error::system_error(error_code ec, const char* what_arg)
-    : runtime_error(make_error_str(ec, what_arg)),
-      __ec_(ec)
-{
-}
+    : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
 
-system_error::system_error(error_code ec)
-    : runtime_error(make_error_str(ec)),
-      __ec_(ec)
-{
-}
+system_error::system_error(error_code ec) : runtime_error(make_error_str(ec)), __ec_(ec) {}
 
 system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
-    : runtime_error(make_error_str(error_code(ev, ecat), what_arg)),
-      __ec_(error_code(ev, ecat))
-{
-}
+    : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
 
 system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
-    : runtime_error(make_error_str(error_code(ev, ecat), what_arg)),
-      __ec_(error_code(ev, ecat))
-{
-}
+    : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
 
 system_error::system_error(int ev, const error_category& ecat)
-    : runtime_error(make_error_str(error_code(ev, ecat))),
-      __ec_(error_code(ev, ecat))
-{
-}
+    : runtime_error(make_error_str(error_code(ev, ecat))), __ec_(error_code(ev, ecat)) {}
 
-system_error::~system_error() noexcept
-{
-}
+system_error::~system_error() noexcept {}
 
-void
-__throw_system_error(int ev, const char* what_arg)
-{
+void __throw_system_error(int ev, const char* what_arg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    std::__throw_system_error(error_code(ev, system_category()), what_arg);
+  std::__throw_system_error(error_code(ev, system_category()), what_arg);
 #else
-    // The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily.
-    _LIBCPP_VERBOSE_ABORT("system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
+  // The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily.
+  _LIBCPP_VERBOSE_ABORT(
+      "system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
 #endif
 }