Reformat with new whitespace penalty

Summary: Applying the formatting change from D67051995 Reviewed By: yfeldblum Differential Revision: D67051993 fbshipit-source-id: e07d73206f964e0c0e05f646162d3da91f3ad6fc
facebook · Dec 11, 2024 · abf77ba · abf77ba
1 parent 048c8f0
commit abf77ba
Show file tree

Hide file tree

Showing 346 changed files with 4,125 additions and 3,395 deletions.
diff --git a/folly/AtomicHashArray-inl.h b/folly/AtomicHashArray-inl.h
@@ -245,8 +245,9 @@ AtomicHashArray<
     }
     DCHECK(relaxedLoadKey(*cell) != kEmptyKey_);
     if (kLockedKey_ == acquireLoadKey(*cell)) {
-      detail::atomic_hash_spin_wait(
-          [&] { return kLockedKey_ == acquireLoadKey(*cell); });
+      detail::atomic_hash_spin_wait([&] {
+        return kLockedKey_ == acquireLoadKey(*cell);
+      });
     }
 
     const KeyT thisKey = acquireLoadKey(*cell);

diff --git a/folly/AtomicHashMap-inl.h b/folly/AtomicHashMap-inl.h
@@ -44,8 +44,9 @@ AtomicHashMap<
     ProbeFcn,
     KeyConvertFcn>::AtomicHashMap(size_t finalSizeEst, const Config& config)
     : kGrowthFrac_(
-          config.growthFactor < 0 ? 1.0f - config.maxLoadFactor
-                                  : config.growthFactor) {
+          config.growthFactor < 0
+              ? 1.0f - config.maxLoadFactor
+              : config.growthFactor) {
   CHECK(config.maxLoadFactor > 0.0f && config.maxLoadFactor < 1.0f);
   subMaps_[0].store(
       SubMap::create(finalSizeEst, config).release(),

diff --git a/folly/AtomicHashMap.h b/folly/AtomicHashMap.h
@@ -390,8 +390,9 @@ class AtomicHashMap {
   }
 
   inline uint32_t recToIdx(value_type&& r, bool mayInsert = true) {
-    SimpleRetT ret = mayInsert ? insertInternal(r.first, std::move(r.second))
-                               : findInternal(r.first);
+    SimpleRetT ret = mayInsert
+        ? insertInternal(r.first, std::move(r.second))
+        : findInternal(r.first);
     return encodeIndex(ret.i, ret.j);
   }
 

diff --git a/folly/AtomicLinkedList.h b/folly/AtomicLinkedList.h
@@ -39,8 +39,9 @@ class AtomicLinkedList {
   AtomicLinkedList& operator=(const AtomicLinkedList&) = delete;
   AtomicLinkedList(AtomicLinkedList&& other) noexcept = default;
   AtomicLinkedList& operator=(AtomicLinkedList&& other) noexcept {
-    list_.reverseSweepAndAssign(
-        std::move(other.list_), [](Wrapper* node) { delete node; });
+    list_.reverseSweepAndAssign(std::move(other.list_), [](Wrapper* node) {
+      delete node;
+    });
     return *this;
   }
 

diff --git a/folly/AtomicUnorderedMap.h b/folly/AtomicUnorderedMap.h
@@ -321,8 +321,9 @@ struct AtomicUnorderedInsertMap {
   /// http://functionalcpp.wordpress.com/2013/08/28/tuple-forwarding/).
   template <class K, class V>
   std::pair<const_iterator, bool> emplace(const K& key, V&& value) {
-    return findOrConstruct(
-        key, [&](void* raw) { new (raw) Value(std::forward<V>(value)); });
+    return findOrConstruct(key, [&](void* raw) {
+      new (raw) Value(std::forward<V>(value));
+    });
   }
 
   const_iterator find(const Key& key) const {

diff --git a/folly/Benchmark.h b/folly/Benchmark.h
@@ -390,8 +390,9 @@ void printResultComparison(
              return rv;                                                      \
            }),                                                               \
        true);                                                                \
-  static void funName([[maybe_unused]] ::folly::UserCounters& counters       \
-                          FOLLY_PP_DETAIL_APPEND_VA_ARG(paramType paramName))
+  static void funName(                                                       \
+      [[maybe_unused]] ::folly::UserCounters& counters                       \
+          FOLLY_PP_DETAIL_APPEND_VA_ARG(paramType paramName))
 
 /**
  * Introduces a benchmark function with support for returning the actual

diff --git a/folly/CancellationToken.cpp b/folly/CancellationToken.cpp
@@ -266,17 +266,19 @@ MergingCancellationState::MergingCancellationState(
     CopyTag, size_t nCopy, const CancellationToken** copyToks)
     : MergingCancellationState() {
   for (size_t i = 0; i < nCopy; ++i, ++callbackEnd_) {
-    new (callbackEnd_)
-        CancellationCallback(*copyToks[i], [this] { requestCancellation(); });
+    new (callbackEnd_) CancellationCallback(*copyToks[i], [this] {
+      requestCancellation();
+    });
   }
 }
 
 MergingCancellationState::MergingCancellationState(
     MoveTag, size_t nMove, CancellationToken** moveToks)
     : MergingCancellationState() {
   for (size_t i = 0; i < nMove; ++i, ++callbackEnd_) {
-    new (callbackEnd_) CancellationCallback(
-        std::move(*moveToks[i]), [this] { requestCancellation(); });
+    new (callbackEnd_) CancellationCallback(std::move(*moveToks[i]), [this] {
+      requestCancellation();
+    });
   }
 }
 
@@ -288,8 +290,9 @@ MergingCancellationState::MergingCancellationState(
     CancellationToken** moveToks)
     : MergingCancellationState(CopyTag{}, nCopy, copyToks) {
   for (size_t i = 0; i < nMove; ++i, ++callbackEnd_) {
-    new (callbackEnd_) CancellationCallback(
-        std::move(*moveToks[i]), [this] { requestCancellation(); });
+    new (callbackEnd_) CancellationCallback(std::move(*moveToks[i]), [this] {
+      requestCancellation();
+    });
   }
 }
 

diff --git a/folly/ConcurrentSkipList-inl.h b/folly/ConcurrentSkipList-inl.h
@@ -80,9 +80,10 @@ class SkipListNode {
   }
 
   template <typename NodeAlloc>
-  struct DestroyIsNoOp : StrictConjunction<
-                             AllocatorHasTrivialDeallocate<NodeAlloc>,
-                             std::is_trivially_destructible<SkipListNode>> {};
+  struct DestroyIsNoOp
+      : StrictConjunction<
+            AllocatorHasTrivialDeallocate<NodeAlloc>,
+            std::is_trivially_destructible<SkipListNode>> {};
 
   // copy the head node to a new head node assuming lock acquired
   SkipListNode* copyHead(SkipListNode* node) {

diff --git a/folly/ConcurrentSkipList.h b/folly/ConcurrentSkipList.h
@@ -278,8 +278,9 @@ class ConcurrentSkipList {
     bool valid = true;
     for (int layer = 0; valid && layer < nodeHeight; ++layer) {
       pred = preds[layer];
-      DCHECK(pred != nullptr) << "layer=" << layer << " height=" << height()
-                              << " nodeheight=" << nodeHeight;
+      DCHECK(pred != nullptr)
+          << "layer=" << layer << " height=" << height()
+          << " nodeheight=" << nodeHeight;
       succ = succs[layer];
       if (pred != prevPred) {
         guards[layer] = pred->acquireGuard();
@@ -414,8 +415,9 @@ class ConcurrentSkipList {
         }
       } while (node != nullptr);
     }
-    return pred == head_.load(std::memory_order_relaxed) ? nullptr
-                                                         : &pred->data();
+    return pred == head_.load(std::memory_order_relaxed)
+        ? nullptr
+        : &pred->data();
   }
 
   static bool okToDelete(NodeType* candidate, int layer) {
@@ -665,10 +667,11 @@ class ConcurrentSkipList<T, Comp, NodeAlloc, MAX_HEIGHT>::Accessor {
 
 // implements forward iterator concept.
 template <typename ValT, typename NodeT>
-class detail::csl_iterator : public detail::IteratorFacade<
-                                 csl_iterator<ValT, NodeT>,
-                                 ValT,
-                                 std::forward_iterator_tag> {
+class detail::csl_iterator
+    : public detail::IteratorFacade<
+          csl_iterator<ValT, NodeT>,
+          ValT,
+          std::forward_iterator_tag> {
  public:
   typedef ValT value_type;
   typedef value_type& reference;
@@ -685,8 +688,9 @@ class detail::csl_iterator : public detail::IteratorFacade<
       : node_(other.node_) {}
 
   size_t nodeSize() const {
-    return node_ == nullptr ? 0
-                            : node_->height() * sizeof(NodeT*) + sizeof(*this);
+    return node_ == nullptr
+        ? 0
+        : node_->height() * sizeof(NodeT*) + sizeof(*this);
   }
 
   bool good() const { return node_ != nullptr; }

diff --git a/folly/ConstexprMath.h b/folly/ConstexprMath.h
@@ -729,9 +729,10 @@ namespace detail {
 template <typename U>
 constexpr std::size_t constexpr_find_first_set_(
     std::size_t s, std::size_t a, U const u) {
-  return s == 0 ? a
-                : constexpr_find_first_set_(
-                      s / 2, a + s * bool((u >> a) % (U(1) << s) == U(0)), u);
+  return s == 0
+      ? a
+      : constexpr_find_first_set_(
+            s / 2, a + s * bool((u >> a) % (U(1) << s) == U(0)), u);
 }
 } // namespace detail
 

diff --git a/folly/Conv.cpp b/folly/Conv.cpp
@@ -434,8 +434,9 @@ class SignedValueHandler<T, true> {
   }
 
   ConversionCode overflow() {
-    return negative_ ? ConversionCode::NEGATIVE_OVERFLOW
-                     : ConversionCode::POSITIVE_OVERFLOW;
+    return negative_
+        ? ConversionCode::NEGATIVE_OVERFLOW
+        : ConversionCode::POSITIVE_OVERFLOW;
   }
 
   template <typename U>
@@ -658,8 +659,9 @@ Expected<Tgt, ConversionCode> str_to_integral(StringPiece* src) noexcept {
 
   if (FOLLY_UNLIKELY(!tmp.hasValue())) {
     return makeUnexpected(
-        tmp.error() == ConversionCode::POSITIVE_OVERFLOW ? sgn.overflow()
-                                                         : tmp.error());
+        tmp.error() == ConversionCode::POSITIVE_OVERFLOW
+            ? sgn.overflow()
+            : tmp.error());
   }
 
   auto res = sgn.finalize(tmp.value());

diff --git a/folly/Conv.h b/folly/Conv.h
@@ -561,8 +561,9 @@ typename std::enable_if<
     sizeof(Src) >= 4>::type
 toAppend(Src value, Tgt* result) {
   char buffer[to_ascii_size_max_decimal<uint64_t>];
-  auto uvalue = value < 0 ? ~static_cast<uint64_t>(value) + 1
-                          : static_cast<uint64_t>(value);
+  auto uvalue = value < 0
+      ? ~static_cast<uint64_t>(value) + 1
+      : static_cast<uint64_t>(value);
   if (value < 0) {
     result->push_back('-');
   }
@@ -575,8 +576,9 @@ typename std::enable_if<
         sizeof(Src) < 16,
     size_t>::type
 estimateSpaceNeeded(Src value) {
-  auto uvalue = value < 0 ? ~static_cast<uint64_t>(value) + 1
-                          : static_cast<uint64_t>(value);
+  auto uvalue = value < 0
+      ? ~static_cast<uint64_t>(value) + 1
+      : static_cast<uint64_t>(value);
   return size_t(value < 0) + to_ascii_size_decimal(uvalue);
 }
 
@@ -1329,8 +1331,9 @@ FOLLY_NODISCARD inline typename std::enable_if< //
     is_arithmetic_v<Tgt>,
     Expected<StringPiece, ConversionCode>>::type
 parseTo(StringPiece src, Tgt& out) {
-  return detail::convertTo<Tgt>(&src).then(
-      [&](Tgt res) { return void(out = res), src; });
+  return detail::convertTo<Tgt>(&src).then([&](Tgt res) {
+    return void(out = res), src;
+  });
 }
 
 /**

diff --git a/folly/Expected.h b/folly/Expected.h
@@ -727,11 +727,12 @@ struct ExpectedHelper {
       class E = ExpectedErrorType<This>,
       class V = ExpectedValueType<This>,
       class T = ExpectedHelper,
-      class RetValue = decltype(T::then_(
-                                    T::template return_<E>((std::declval<No>()(
-                                        std::declval<This>().error()))),
-                                    std::declval<AndFns>()...)
-                                    .value()),
+      class RetValue =
+          decltype(T::then_(
+                       T::template return_<E>(
+                           (std::declval<No>()(std::declval<This>().error()))),
+                       std::declval<AndFns>()...)
+                       .value()),
       typename std::enable_if<!std::is_same<
           std::remove_reference<RetValue>,
           std::remove_reference<folly::Unit&&>>::value>::type* = nullptr,
@@ -763,11 +764,12 @@ struct ExpectedHelper {
       class... AndFns,
       class E = ExpectedErrorType<This>,
       class T = ExpectedHelper,
-      class RetValue = decltype(T::then_(
-                                    T::template return_<E>((std::declval<No>()(
-                                        std::declval<This>().error()))),
-                                    std::declval<AndFns>()...)
-                                    .value()),
+      class RetValue =
+          decltype(T::then_(
+                       T::template return_<E>(
+                           (std::declval<No>()(std::declval<This>().error()))),
+                       std::declval<AndFns>()...)
+                       .value()),
       typename std::enable_if<std::is_same<
           std::remove_reference<RetValue>,
           std::remove_reference<folly::Unit&&>>::value>::type* = nullptr,
@@ -1271,9 +1273,9 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
   }
 
   template <class... Fns FOLLY_REQUIRES_TRAILING(sizeof...(Fns) >= 1)>
-  auto then(Fns&&... fns) & -> decltype(expected_detail::ExpectedHelper::then_(
-                                std::declval<Base&>(),
-                                std::declval<Fns>()...)) {
+  auto
+  then(Fns&&... fns) & -> decltype(expected_detail::ExpectedHelper::then_(
+                           std::declval<Base&>(), std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1282,9 +1284,9 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
   }
 
   template <class... Fns FOLLY_REQUIRES_TRAILING(sizeof...(Fns) >= 1)>
-  auto then(Fns&&... fns) && -> decltype(expected_detail::ExpectedHelper::then_(
-                                 std::declval<Base&&>(),
-                                 std::declval<Fns>()...)) {
+  auto
+  then(Fns&&... fns) && -> decltype(expected_detail::ExpectedHelper::then_(
+                            std::declval<Base&&>(), std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1344,8 +1346,10 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
   }
 
   template <class Yes, class No = MakeBadExpectedAccess>
-  auto thenOrThrow(Yes&& yes, No&& no = No{}) & -> decltype(std::declval<Yes>()(
-                                                    std::declval<Value&>())) {
+  auto thenOrThrow(
+      Yes&& yes,
+      No&& no =
+          No{}) & -> decltype(std::declval<Yes>()(std::declval<Value&>())) {
     using Ret = decltype(std::declval<Yes>()(std::declval<Value&>()));
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();

diff --git a/folly/FBString.h b/folly/FBString.h
@@ -1780,10 +1780,11 @@ class basic_fbstring {
 template <typename E, class T, class A, class S>
 FOLLY_NOINLINE typename basic_fbstring<E, T, A, S>::size_type
 basic_fbstring<E, T, A, S>::traitsLength(const value_type* s) {
-  return s ? traits_type::length(s)
-           : (throw_exception<std::logic_error>(
-                  "basic_fbstring: null pointer initializer not valid"),
-              0);
+  return s
+      ? traits_type::length(s)
+      : (throw_exception<std::logic_error>(
+             "basic_fbstring: null pointer initializer not valid"),
+         0);
 }
 
 template <typename E, class T, class A, class S>