clang-format

Author: vinay-deshmukh

libc/src/__support/OSUtil/darwin/io.h

@@ -17,7 +17,8 @@ namespace LIBC_NAMESPACE_DECL {
 
 LIBC_INLINE void write_to_stderr(cpp::string_view msg) {
   LIBC_NAMESPACE::syscall_impl(4 /*SYS_write*/, 2 /* stderr */,
-                               reinterpret_cast<long>(msg.data()), static_cast<long>(msg.size()));
+                               reinterpret_cast<long>(msg.data()),
+                               static_cast<long>(msg.size()));
 }
 
 } // namespace LIBC_NAMESPACE_DECL

libc/src/__support/high_precision_decimal.h

@@ -424,8 +424,8 @@ class HighPrecisionDecimal {
       result *= 10;
       ++cur_digit;
     }
-    return result + static_cast<T>(
-                        this->should_round_up(this->decimal_point, round));
+    return result +
+           static_cast<T>(this->should_round_up(this->decimal_point, round));
   }
 
   // Extra functions for testing.

libc/src/__support/memory_size.h

@@ -77,7 +77,8 @@ class SafeMemSize {
     if (!cpp::has_single_bit(alignment) || alignment > MAX_MEM_SIZE || !valid())
       return SafeMemSize{type{-1}};
 
-    type offset = static_cast<type>(offset_to(static_cast<size_t>(value), alignment));
+    type offset =
+        static_cast<type>(offset_to(static_cast<size_t>(value), alignment));
 
     if (LIBC_UNLIKELY(offset > static_cast<type>(MAX_MEM_SIZE) - value))
       return SafeMemSize{type{-1}};

libc/src/__support/str_to_float.h

@@ -111,8 +111,8 @@ eisel_lemire(ExpandedFloat<T> init_num,
   uint32_t clz = static_cast<uint32_t>(cpp::countl_zero<StorageType>(mantissa));
   mantissa <<= clz;
 
-  int32_t exp2 =
-      exp10_to_exp2(exp10) + FPBits::STORAGE_LEN + FPBits::EXP_BIAS - static_cast<int32_t>(clz);
+  int32_t exp2 = exp10_to_exp2(exp10) + FPBits::STORAGE_LEN + FPBits::EXP_BIAS -
+                 static_cast<int32_t>(clz);
 
   // Multiplication
   const uint64_t *power_of_ten =

libc/src/stdio/printf_core/parser.h

@@ -57,7 +57,8 @@ template <typename T> using int_type_of_v = typename int_type_of<T>::type;
     if (!temp.has_value()) {                                                   \
       section.has_conv = false;                                                \
     } else {                                                                   \
-      dst = static_cast<decltype(dst)>(cpp::bit_cast<int_type_of_v<arg_type>>(temp.value()));              \
+      dst = static_cast<decltype(dst)>(                                        \
+          cpp::bit_cast<int_type_of_v<arg_type>>(temp.value()));               \
     }                                                                          \
   }
 #else
@@ -265,7 +266,8 @@ template <typename ArgProvider> class Parser {
       case ('m'):
         // %m is an odd conversion in that it doesn't consume an argument, it
         // just takes the current value of errno as its argument.
-        section.conv_val_raw = static_cast<fputil::FPBits<double>::StorageType>(libc_errno);
+        section.conv_val_raw =
+            static_cast<fputil::FPBits<double>::StorageType>(libc_errno);
         break;
 #endif // LIBC_COPT_PRINTF_DISABLE_STRERROR
 #ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT

libc/src/stdio/printf_core/writer.h

@@ -135,7 +135,8 @@ class Writer final {
     chars_written += static_cast<int>(length);
 
     if (LIBC_LIKELY(wb->buff_cur + length <= wb->buff_len)) {
-      inline_memset(wb->buff + wb->buff_cur, static_cast<unsigned char>(new_char), length);
+      inline_memset(wb->buff + wb->buff_cur,
+                    static_cast<unsigned char>(new_char), length);
       wb->buff_cur += length;
       return WRITE_OK;
     }

libc/src/stdio/scanf_core/parser.h

@@ -150,7 +150,8 @@ template <typename ArgProvider> class Parser {
             char b = str[cur_pos + 1];
             char start = (a < b ? a : b);
             char end = (a < b ? b : a);
-            scan_set.set_range(static_cast<size_t>(start), static_cast<size_t>(end));
+            scan_set.set_range(static_cast<size_t>(start),
+                               static_cast<size_t>(end));
             cur_pos += 2;
           } else {
             scan_set.set(static_cast<size_t>(str[cur_pos]));

libc/src/stdlib/quick_sort.h

@@ -167,7 +167,9 @@ LIBC_INLINE void quick_sort_impl(A &array, const void *ancestor_pivot,
   }
 }
 
-constexpr size_t ilog2(size_t n) { return static_cast<size_t>(cpp::bit_width(n)) - 1; }
+constexpr size_t ilog2(size_t n) {
+  return static_cast<size_t>(cpp::bit_width(n)) - 1;
+}
 
 template <typename A, typename F>
 LIBC_INLINE void quick_sort(A &array, const F &is_less) {

libc/test/src/__support/integer_to_string_test.cpp

@@ -181,7 +181,8 @@ TEST(LlvmLibcIntegerToStringTest, UINT64_Base_8) {
   EXPECT(type, 0, "0");
   EXPECT(type, 012345, "12345");
   EXPECT(type, 0123456701234567012345, "123456701234567012345");
-  EXPECT(type, static_cast<int64_t>(01777777777777777777777), "1777777777777777777777");
+  EXPECT(type, static_cast<int64_t>(01777777777777777777777),
+         "1777777777777777777777");
 }
 
 TEST(LlvmLibcIntegerToStringTest, UINT64_Base_16) {

libc/test/src/__support/math_extras_test.cpp

@@ -74,18 +74,15 @@ TYPED_TEST(LlvmLibcBitTest, FirstLeadingZero, UnsignedTypesNoBigInt) {
   EXPECT_EQ(first_leading_zero<T>(cpp::numeric_limits<T>::max()), 0);
   for (int i = 0U; i != cpp::numeric_limits<T>::digits; ++i) {
     auto lhs = T(~(T(1) << size_t(i)));
-    EXPECT_EQ(first_leading_zero<T>(lhs),
-              cpp::numeric_limits<T>::digits - i);
+    EXPECT_EQ(first_leading_zero<T>(lhs), cpp::numeric_limits<T>::digits - i);
   }
 }
 
 TYPED_TEST(LlvmLibcBitTest, FirstLeadingOne, UnsignedTypesNoBigInt) {
   EXPECT_EQ(first_leading_one<T>(static_cast<T>(0)), 0);
   for (int i = 0U; i != cpp::numeric_limits<T>::digits; ++i) {
     auto lhs = T(T(1) << size_t(i));
-    EXPECT_EQ(first_leading_one<T>(lhs),
-              cpp::numeric_limits<T>::digits - i);
-
+    EXPECT_EQ(first_leading_one<T>(lhs), cpp::numeric_limits<T>::digits - i);
   }
 }