diff --git a/folly/AtomicHashMap-inl.h b/folly/AtomicHashMap-inl.h
index 41988d189af..c73c13e90c9 100644
--- a/folly/AtomicHashMap-inl.h
+++ b/folly/AtomicHashMap-inl.h
@@ -164,7 +164,8 @@ AtomicHashMap<
     // Alloc a new map and shove it in.  We can change whatever
     // we want because other threads are waiting on us...
     size_t numCellsAllocated =
-        (size_t)(primarySubMap->capacity_ * std::pow(1.0 + kGrowthFrac_, nextMapIdx - 1));
+        (size_t)(primarySubMap->capacity_ *
+                 std::pow(1.0 + kGrowthFrac_, nextMapIdx - 1));
     size_t newSize = size_t(numCellsAllocated * kGrowthFrac_);
     DCHECK(
         subMaps_[nextMapIdx].load(std::memory_order_relaxed) ==
diff --git a/folly/AtomicUnorderedMap.h b/folly/AtomicUnorderedMap.h
index b974d60435e..bfd58e16cb8 100644
--- a/folly/AtomicUnorderedMap.h
+++ b/folly/AtomicUnorderedMap.h
@@ -271,10 +271,14 @@ struct AtomicUnorderedInsertMap {
     // else in this function can throw an exception. In the event of an
     // exception, deallocate as if the KV was beaten in a concurrent addition.
     const auto idx = allocateNear(slot);
-    SCOPE_FAIL { slots_[idx].stateUpdate(CONSTRUCTING, EMPTY); };
+    SCOPE_FAIL {
+      slots_[idx].stateUpdate(CONSTRUCTING, EMPTY);
+    };
     Key* addr = &slots_[idx].keyValue().first;
     new (addr) Key(key);
-    SCOPE_FAIL { addr->~Key(); };
+    SCOPE_FAIL {
+      addr->~Key();
+    };
     func(static_cast<void*>(&slots_[idx].keyValue().second));
 
     while (true) {
diff --git a/folly/Benchmark.h b/folly/Benchmark.h
index 6b7a38d0741..1cf7b464b22 100644
--- a/folly/Benchmark.h
+++ b/folly/Benchmark.h
@@ -165,7 +165,9 @@ struct BenchmarkSuspender : BenchmarkSuspenderBase {
 
   template <class F>
   auto dismissing(F f) -> invoke_result_t<F> {
-    SCOPE_EXIT { rehire(); };
+    SCOPE_EXIT {
+      rehire();
+    };
     dismiss();
     return f();
   }
diff --git a/folly/Expected.h b/folly/Expected.h
index 734bcaa40f1..823ac6c6884 100644
--- a/folly/Expected.h
+++ b/folly/Expected.h
@@ -660,10 +660,11 @@ struct ExpectedHelper {
       class... Fns,
       class E = ExpectedErrorType<This>,
       class T = ExpectedHelper>
-  static auto then_(This&& ex, Fn&& fn, Fns&&... fns) -> decltype(T::then_(
-      T::template return_<E>(
-          (std::declval<Fn>()(std::declval<This>().value()), unit)),
-      std::declval<Fns>()...)) {
+  static auto then_(This&& ex, Fn&& fn, Fns&&... fns)
+      -> decltype(T::then_(
+          T::template return_<E>(
+              (std::declval<Fn>()(std::declval<This>().value()), unit)),
+          std::declval<Fns>()...)) {
     if (FOLLY_LIKELY(ex.which_ == expected_detail::Which::eValue)) {
       return T::then_(
           T::template return_<E>(
@@ -1122,7 +1123,8 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
    * swap
    */
   void swap(Expected& that) noexcept(
-      std::is_nothrow_swappable_v<Value>&& std::is_nothrow_swappable_v<Error>) {
+      std::is_nothrow_swappable_v<Value> &&
+      std::is_nothrow_swappable_v<Error>) {
     if (this->uninitializedByException() || that.uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1249,7 +1251,7 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
   template <class... Fns FOLLY_REQUIRES_TRAILING(sizeof...(Fns) >= 1)>
   auto then(Fns&&... fns)
       const& -> decltype(expected_detail::ExpectedHelper::then_(
-          std::declval<const Base&>(), std::declval<Fns>()...)) {
+                 std::declval<const Base&>(), std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1259,7 +1261,8 @@ 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>()...)) {
+                                std::declval<Base&>(),
+                                std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1269,7 +1272,8 @@ 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>()...)) {
+                                 std::declval<Base&&>(),
+                                 std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1284,7 +1288,7 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
   template <class... Fns FOLLY_REQUIRES_TRAILING(sizeof...(Fns) >= 1)>
   auto orElse(Fns&&... fns)
       const& -> decltype(expected_detail::ExpectedHelper::orElse_(
-          std::declval<const Base&>(), std::declval<Fns>()...)) {
+                 std::declval<const Base&>(), std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1295,7 +1299,7 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
   template <class... Fns FOLLY_REQUIRES_TRAILING(sizeof...(Fns) >= 1)>
   auto
   orElse(Fns&&... fns) & -> decltype(expected_detail::ExpectedHelper::orElse_(
-      std::declval<Base&>(), std::declval<Fns>()...)) {
+                             std::declval<Base&>(), std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1306,7 +1310,7 @@ class Expected final : expected_detail::ExpectedStorage<Value, Error> {
   template <class... Fns FOLLY_REQUIRES_TRAILING(sizeof...(Fns) >= 1)>
   auto
   orElse(Fns&&... fns) && -> decltype(expected_detail::ExpectedHelper::orElse_(
-      std::declval<Base&&>(), std::declval<Fns>()...)) {
+                              std::declval<Base&&>(), std::declval<Fns>()...)) {
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
     }
@@ -1330,7 +1334,7 @@ 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&>())) {
+                                                    std::declval<Value&>())) {
     using Ret = decltype(std::declval<Yes>()(std::declval<Value&>()));
     if (this->uninitializedByException()) {
       throw_exception<BadExpectedAccess<void>>();
@@ -1459,7 +1463,7 @@ inline bool operator>=(
  */
 template <class Value, class Error>
 void swap(Expected<Value, Error>& lhs, Expected<Value, Error>& rhs) noexcept(
-    std::is_nothrow_swappable_v<Value>&& std::is_nothrow_swappable_v<Error>) {
+    std::is_nothrow_swappable_v<Value> && std::is_nothrow_swappable_v<Error>) {
   lhs.swap(rhs);
 }
 
diff --git a/folly/File.cpp b/folly/File.cpp
index f61fc3cc736..b0ac777cedd 100644
--- a/folly/File.cpp
+++ b/folly/File.cpp
@@ -76,7 +76,9 @@ File::~File() {
   // make a temp file with tmpfile(), dup the fd, then return it in a File.
   FILE* tmpFile = tmpfile();
   checkFopenError(tmpFile, "tmpfile() failed");
-  SCOPE_EXIT { fclose(tmpFile); };
+  SCOPE_EXIT {
+    fclose(tmpFile);
+  };
 
   // TODO(nga): consider setting close-on-exec for the resulting FD
   int fd = ::dup(fileno(tmpFile));
diff --git a/folly/Function.h b/folly/Function.h
index 57c6f77d94d..3dd8705ef93 100644
--- a/folly/Function.h
+++ b/folly/Function.h
@@ -264,7 +264,7 @@ constexpr bool isEmptyFunction(T const& t) {
 }
 
 template <typename F, typename... Args>
-using CallableResult = decltype(FOLLY_DECLVAL(F &&)(FOLLY_DECLVAL(Args &&)...));
+using CallableResult = decltype(FOLLY_DECLVAL(F&&)(FOLLY_DECLVAL(Args&&)...));
 
 template <typename F, typename... Args>
 constexpr bool CallableNoexcept =
diff --git a/folly/IPAddressV6.cpp b/folly/IPAddressV6.cpp
index 32a15e685cb..39a1313aad6 100644
--- a/folly/IPAddressV6.cpp
+++ b/folly/IPAddressV6.cpp
@@ -107,7 +107,9 @@ Expected<IPAddressV6, IPAddressFormatError> IPAddressV6::tryFromString(
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags = AI_NUMERICHOST;
   if (::getaddrinfo(ipBuffer.data(), nullptr, &hints, &result) == 0) {
-    SCOPE_EXIT { ::freeaddrinfo(result); };
+    SCOPE_EXIT {
+      ::freeaddrinfo(result);
+    };
     const struct sockaddr_in6* sa =
         reinterpret_cast<struct sockaddr_in6*>(result->ai_addr);
     return IPAddressV6(*sa);
diff --git a/folly/Indestructible.h b/folly/Indestructible.h
index 682fef88af4..6757a6909dc 100644
--- a/folly/Indestructible.h
+++ b/folly/Indestructible.h
@@ -140,7 +140,7 @@ class Indestructible final {
   T const* operator->() const noexcept { return get(); }
 
   /* implicit */ operator T&() noexcept { return *get(); }
-  /* implicit */ operator T const &() const noexcept { return *get(); }
+  /* implicit */ operator T const&() const noexcept { return *get(); }
 
  private:
   struct Storage {
diff --git a/folly/Overload.h b/folly/Overload.h
index 72525d91ec0..2147a0dc6bb 100644
--- a/folly/Overload.h
+++ b/folly/Overload.h
@@ -64,7 +64,7 @@ struct FunctionClassType<Return (*)(Args...)
     /* implicit */ constexpr type(Ptr function) noexcept
         : function_(function) {}
     constexpr auto operator()(Args... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return function_(std::forward<Args>(args)...);
     }
 
@@ -90,11 +90,11 @@ struct FunctionClassType<Return (Self::*)(Args...)
     /* implicit */ constexpr type(Ptr memberPointer) noexcept
         : memberPointer_(memberPointer) {}
     constexpr auto operator()(Self& self, Args... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return (self.*memberPointer_)(std::forward<Args>(args)...);
     }
     constexpr auto operator()(Self&& self, Args... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return (self.*memberPointer_)(std::forward<Args>(args)...);
     }
 
@@ -115,7 +115,7 @@ struct FunctionClassType<Return (Self::*)(Args...)
     /* implicit */ constexpr type(Ptr memberPointer) noexcept
         : memberPointer_(memberPointer) {}
     constexpr auto operator()(const Self& self, Args... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return (self.*memberPointer_)(std::forward<Args>(args)...);
     }
 
@@ -135,7 +135,7 @@ struct FunctionClassType<
     /* implicit */ constexpr type(Ptr memberPointer) noexcept
         : memberPointer_(memberPointer) {}
     constexpr auto operator()(Self& self, Args&&... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return (self.*memberPointer_)(std::forward<Args>(args)...);
     }
 
@@ -156,7 +156,7 @@ struct FunctionClassType<
     /* implicit */ constexpr type(Ptr memberPointer) noexcept
         : memberPointer_(memberPointer) {}
     constexpr auto operator()(const Self& self, Args... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return (self.*memberPointer_)(std::forward<Args>(args)...);
     }
 
@@ -176,7 +176,7 @@ struct FunctionClassType<
     /* implicit */ constexpr type(Ptr memberPointer) noexcept
         : memberPointer_(memberPointer) {}
     constexpr auto operator()(Self&& self, Args... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return (std::move(self).*memberPointer_)(std::forward<Args>(args)...);
     }
 
@@ -197,7 +197,7 @@ struct FunctionClassType<
     /* implicit */ constexpr type(Ptr memberPointer) noexcept
         : memberPointer_(memberPointer) {}
     constexpr auto operator()(const Self&& self, Args... args) const
-        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION -> Return {
+        FOLLY_DETAIL_NOEXCEPT_SPECIFICATION->Return {
       return (std::move(self).*memberPointer_)(std::forward<Args>(args)...);
     }
 
diff --git a/folly/Poly.h b/folly/Poly.h
index baa2d3775f9..7bf7edb7d26 100644
--- a/folly/Poly.h
+++ b/folly/Poly.h
@@ -217,7 +217,8 @@ template <
     typename... As,
     std::enable_if_t<detail::IsPoly<Poly>::value, int> = 0>
 auto poly_call(Poly&& _this, As&&... as) -> decltype(poly_call<N, I>(
-    static_cast<Poly&&>(_this).get(), static_cast<As&&>(as)...)) {
+                                             static_cast<Poly&&>(_this).get(),
+                                             static_cast<As&&>(as)...)) {
   return poly_call<N, I>(
       static_cast<Poly&&>(_this).get(), static_cast<As&&>(as)...);
 }
diff --git a/folly/Replaceable.h b/folly/Replaceable.h
index a97cd6e4d43..233ea1e4026 100644
--- a/folly/Replaceable.h
+++ b/folly/Replaceable.h
@@ -280,8 +280,8 @@ struct move_assignment_mixin<T, true> {
   move_assignment_mixin(move_assignment_mixin const&) = default;
   inline move_assignment_mixin&
   operator=(move_assignment_mixin&& other) noexcept(
-      std::is_nothrow_destructible<T>::value&&
-          std::is_nothrow_move_constructible<T>::value) {
+      std::is_nothrow_destructible<T>::value &&
+      std::is_nothrow_move_constructible<T>::value) {
     T* destruct_ptr = std::launder(reinterpret_cast<T*>(
         reinterpret_cast<Replaceable<T>*>(this)->storage_));
     destruct_ptr->~T();
@@ -344,8 +344,8 @@ struct copy_assignment_mixin<T, true> {
   copy_assignment_mixin& operator=(copy_assignment_mixin&&) = default;
   inline copy_assignment_mixin&
   operator=(copy_assignment_mixin const& other) noexcept(
-      std::is_nothrow_destructible<T>::value&&
-          std::is_nothrow_copy_constructible<T>::value) {
+      std::is_nothrow_destructible<T>::value &&
+      std::is_nothrow_copy_constructible<T>::value) {
     T* destruct_ptr = std::launder(reinterpret_cast<T*>(
         reinterpret_cast<Replaceable<T>*>(this)->storage_));
     destruct_ptr->~T();
diff --git a/folly/String.cpp b/folly/String.cpp
index 9c2e9521f91..e4ee383f1d1 100644
--- a/folly/String.cpp
+++ b/folly/String.cpp
@@ -220,7 +220,9 @@ void stringAppendfImpl(std::string& output, const char* format, va_list args) {
 std::string stringPrintf(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
-  SCOPE_EXIT { va_end(ap); };
+  SCOPE_EXIT {
+    va_end(ap);
+  };
   return stringVPrintf(format, ap);
 }
 
@@ -235,7 +237,9 @@ std::string stringVPrintf(const char* format, va_list ap) {
 std::string& stringAppendf(std::string* output, const char* format, ...) {
   va_list ap;
   va_start(ap, format);
-  SCOPE_EXIT { va_end(ap); };
+  SCOPE_EXIT {
+    va_end(ap);
+  };
   return stringVAppendf(output, format, ap);
 }
 
@@ -248,7 +252,9 @@ std::string& stringVAppendf(
 void stringPrintf(std::string* output, const char* format, ...) {
   va_list ap;
   va_start(ap, format);
-  SCOPE_EXIT { va_end(ap); };
+  SCOPE_EXIT {
+    va_end(ap);
+  };
   return stringVPrintf(output, format, ap);
 }
 
diff --git a/folly/Subprocess.cpp b/folly/Subprocess.cpp
index 6e2793bb213..bcc6ed14ad2 100644
--- a/folly/Subprocess.cpp
+++ b/folly/Subprocess.cpp
@@ -153,8 +153,7 @@ SubprocessSpawnError::SubprocessSpawnError(
 namespace {
 
 // Copy pointers to the given strings in a format suitable for posix_spawn
-std::unique_ptr<const char* []> cloneStrings(
-    const std::vector<std::string>& s) {
+std::unique_ptr<const char*[]> cloneStrings(const std::vector<std::string>& s) {
   std::unique_ptr<const char*[]> d(new const char*[s.size() + 1]);
   for (size_t i = 0; i < s.size(); i++) {
     d[i] = s[i].c_str();
diff --git a/folly/Synchronized.h b/folly/Synchronized.h
index 338c048b60e..5bb2587beb5 100644
--- a/folly/Synchronized.h
+++ b/folly/Synchronized.h
@@ -1738,8 +1738,9 @@ void swap(Synchronized<T, M>& lhs, Synchronized<T, M>& rhs) {
 
 namespace detail {
 struct [[deprecated(
-    "use explicit lock(), wlock(), or rlock() instead")]] SYNCHRONIZED_macro_is_deprecated{};
-}
+    "use explicit lock(), wlock(), or rlock() instead")]] SYNCHRONIZED_macro_is_deprecated {
+};
+} // namespace detail
 
 /**
  * NOTE: This API is deprecated.  Use lock(), wlock(), rlock() or the withLock
diff --git a/folly/Utility.h b/folly/Utility.h
index 6ac6f235397..745a708e089 100644
--- a/folly/Utility.h
+++ b/folly/Utility.h
@@ -58,7 +58,7 @@ template <typename T>
 T* decay_1_(T*);
 
 template <typename T>
-auto decay_0_(int) -> decltype(detail::decay_1_(FOLLY_DECLVAL(T &&)));
+auto decay_0_(int) -> decltype(detail::decay_1_(FOLLY_DECLVAL(T&&)));
 template <typename T>
 auto decay_0_(short) -> void;
 
@@ -277,8 +277,8 @@ struct inheritable_contain_ {
       : v(static_cast<A&&>(a)...) {}
   FOLLY_ERASE operator T&() & noexcept { return v; }
   FOLLY_ERASE operator T&&() && noexcept { return static_cast<T&&>(v); }
-  FOLLY_ERASE operator T const &() const& noexcept { return v; }
-  FOLLY_ERASE operator T const &&() const&& noexcept {
+  FOLLY_ERASE operator T const&() const& noexcept { return v; }
+  FOLLY_ERASE operator T const&&() const&& noexcept {
     return static_cast<T const&&>(v);
   }
 };
diff --git a/folly/concurrency/ThreadCachedSynchronized.h b/folly/concurrency/ThreadCachedSynchronized.h
index b0090fba332..15a6e486bc0 100644
--- a/folly/concurrency/ThreadCachedSynchronized.h
+++ b/folly/concurrency/ThreadCachedSynchronized.h
@@ -96,8 +96,8 @@ class thread_cached_synchronized {
   using tlp_cache_state = ThreadLocalPtr<cache_state>;
 
   template <typename... A>
-  static constexpr bool nx = noexcept(truth_state{
-      std::in_place, FOLLY_DECLVAL(A)...});
+  static constexpr bool nx =
+      noexcept(truth_state{std::in_place, FOLLY_DECLVAL(A)...});
 
   template <bool C>
   using if_ = std::enable_if_t<C, int>;
diff --git a/folly/concurrency/test/ConcurrentHashMapBench.cpp b/folly/concurrency/test/ConcurrentHashMapBench.cpp
index 28406f355ad..25e37cf585f 100644
--- a/folly/concurrency/test/ConcurrentHashMapBench.cpp
+++ b/folly/concurrency/test/ConcurrentHashMapBench.cpp
@@ -214,8 +214,7 @@ void benches() {
             << std::endl;
   for (int nthr : {1, 10}) {
     std::cout << "========================= " << std::setw(2) << nthr
-              << " threads"
-              << " =========================" << std::endl;
+              << " threads" << " =========================" << std::endl;
     bench_ctor_dtor(nthr, 0, "CHM ctor/dtor -- empty          ");
     bench_ctor_dtor(nthr, 1, "CHM ctor/dtor -- 1 item         ");
     dottedLine();
diff --git a/folly/container/Access.h b/folly/container/Access.h
index 91ca8a3802b..8b221fd55f7 100644
--- a/folly/container/Access.h
+++ b/folly/container/Access.h
@@ -64,8 +64,8 @@ inline constexpr empty_fn empty{};
 //  mimic: std::data, C++17
 struct data_fn {
   template <typename C>
-  FOLLY_ERASE constexpr auto operator()(C& c) const noexcept(noexcept(c.data()))
-      -> decltype(c.data()) {
+  FOLLY_ERASE constexpr auto operator()(C& c) const
+      noexcept(noexcept(c.data())) -> decltype(c.data()) {
     return c.data();
   }
   template <typename C>
diff --git a/folly/container/F14Map.h b/folly/container/F14Map.h
index bbef7615f7e..2eb42111bea 100644
--- a/folly/container/F14Map.h
+++ b/folly/container/F14Map.h
@@ -1190,12 +1190,13 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14ValueMap(InputIt, InputIt, std::size_t, Alloc) -> F14ValueMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    f14::DefaultHasher<iterator_key_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14ValueMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14ValueMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -1204,12 +1205,13 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14ValueMap(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14ValueMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14ValueMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14ValueMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1338,12 +1340,13 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14NodeMap(InputIt, InputIt, std::size_t, Alloc) -> F14NodeMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    f14::DefaultHasher<iterator_key_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14NodeMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14NodeMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -1352,12 +1355,13 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14NodeMap(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14NodeMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14NodeMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14NodeMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1745,12 +1749,13 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14VectorMap(InputIt, InputIt, std::size_t, Alloc) -> F14VectorMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    f14::DefaultHasher<iterator_key_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14VectorMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14VectorMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -1759,12 +1764,13 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14VectorMap(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14VectorMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14VectorMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14VectorMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1880,12 +1886,13 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14FastMap(InputIt, InputIt, std::size_t, Alloc) -> F14FastMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    f14::DefaultHasher<iterator_key_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14FastMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14FastMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -1894,12 +1901,13 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14FastMap(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14FastMap<
-    iterator_key_type_t<InputIt>,
-    iterator_mapped_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
-    Alloc>;
+F14FastMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14FastMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
diff --git a/folly/container/F14Set.h b/folly/container/F14Set.h
index 7f8c158b0c0..9d1fa2f1c00 100644
--- a/folly/container/F14Set.h
+++ b/folly/container/F14Set.h
@@ -879,11 +879,12 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14ValueSet(InputIt, InputIt, std::size_t, Alloc) -> F14ValueSet<
-    iterator_value_type_t<InputIt>,
-    f14::DefaultHasher<iterator_value_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14ValueSet(InputIt, InputIt, std::size_t, Alloc)
+    -> F14ValueSet<
+        iterator_value_type_t<InputIt>,
+        f14::DefaultHasher<iterator_value_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -892,11 +893,12 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14ValueSet(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14ValueSet<
-    iterator_value_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14ValueSet(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14ValueSet<
+        iterator_value_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
@@ -917,11 +919,12 @@ template <
     typename Key,
     typename Alloc,
     typename = detail::RequireAllocator<Alloc>>
-F14ValueSet(std::initializer_list<Key>, std::size_t, Alloc) -> F14ValueSet<
-    Key,
-    f14::DefaultHasher<Key>,
-    f14::DefaultKeyEqual<Key>,
-    Alloc>;
+F14ValueSet(std::initializer_list<Key>, std::size_t, Alloc)
+    -> F14ValueSet<
+        Key,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
 
 template <
     typename Key,
@@ -995,11 +998,12 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14NodeSet(InputIt, InputIt, std::size_t, Alloc) -> F14NodeSet<
-    iterator_value_type_t<InputIt>,
-    f14::DefaultHasher<iterator_value_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14NodeSet(InputIt, InputIt, std::size_t, Alloc)
+    -> F14NodeSet<
+        iterator_value_type_t<InputIt>,
+        f14::DefaultHasher<iterator_value_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -1008,11 +1012,12 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14NodeSet(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14NodeSet<
-    iterator_value_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14NodeSet(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14NodeSet<
+        iterator_value_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1033,11 +1038,12 @@ template <
     typename Key,
     typename Alloc,
     typename = detail::RequireAllocator<Alloc>>
-F14NodeSet(std::initializer_list<Key>, std::size_t, Alloc) -> F14NodeSet<
-    Key,
-    f14::DefaultHasher<Key>,
-    f14::DefaultKeyEqual<Key>,
-    Alloc>;
+F14NodeSet(std::initializer_list<Key>, std::size_t, Alloc)
+    -> F14NodeSet<
+        Key,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1311,11 +1317,12 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14VectorSet(InputIt, InputIt, std::size_t, Alloc) -> F14VectorSet<
-    iterator_value_type_t<InputIt>,
-    f14::DefaultHasher<iterator_value_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14VectorSet(InputIt, InputIt, std::size_t, Alloc)
+    -> F14VectorSet<
+        iterator_value_type_t<InputIt>,
+        f14::DefaultHasher<iterator_value_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -1324,11 +1331,12 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14VectorSet(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14VectorSet<
-    iterator_value_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14VectorSet(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14VectorSet<
+        iterator_value_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1349,11 +1357,12 @@ template <
     typename Key,
     typename Alloc,
     typename = detail::RequireAllocator<Alloc>>
-F14VectorSet(std::initializer_list<Key>, std::size_t, Alloc) -> F14VectorSet<
-    Key,
-    f14::DefaultHasher<Key>,
-    f14::DefaultKeyEqual<Key>,
-    Alloc>;
+F14VectorSet(std::initializer_list<Key>, std::size_t, Alloc)
+    -> F14VectorSet<
+        Key,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1413,11 +1422,12 @@ template <
     typename Alloc,
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireAllocator<Alloc>>
-F14FastSet(InputIt, InputIt, std::size_t, Alloc) -> F14FastSet<
-    iterator_value_type_t<InputIt>,
-    f14::DefaultHasher<iterator_value_type_t<InputIt>>,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14FastSet(InputIt, InputIt, std::size_t, Alloc)
+    -> F14FastSet<
+        iterator_value_type_t<InputIt>,
+        f14::DefaultHasher<iterator_value_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename InputIt,
@@ -1426,11 +1436,12 @@ template <
     typename = detail::RequireInputIterator<InputIt>,
     typename = detail::RequireNotAllocator<Hasher>,
     typename = detail::RequireAllocator<Alloc>>
-F14FastSet(InputIt, InputIt, std::size_t, Hasher, Alloc) -> F14FastSet<
-    iterator_value_type_t<InputIt>,
-    Hasher,
-    f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
-    Alloc>;
+F14FastSet(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14FastSet<
+        iterator_value_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_value_type_t<InputIt>>,
+        Alloc>;
 
 template <
     typename Key,
@@ -1451,11 +1462,12 @@ template <
     typename Key,
     typename Alloc,
     typename = detail::RequireAllocator<Alloc>>
-F14FastSet(std::initializer_list<Key>, std::size_t, Alloc) -> F14FastSet<
-    Key,
-    f14::DefaultHasher<Key>,
-    f14::DefaultKeyEqual<Key>,
-    Alloc>;
+F14FastSet(std::initializer_list<Key>, std::size_t, Alloc)
+    -> F14FastSet<
+        Key,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
 
 template <
     typename Key,
diff --git a/folly/container/detail/F14Table.h b/folly/container/detail/F14Table.h
index c6941c51817..5c6ec888355 100644
--- a/folly/container/detail/F14Table.h
+++ b/folly/container/detail/F14Table.h
@@ -1264,9 +1264,9 @@ class F14Table : public Policy {
   }
 
   F14Table(F14Table&& rhs) noexcept(
-      std::is_nothrow_move_constructible<Hasher>::value&&
-          std::is_nothrow_move_constructible<KeyEqual>::value&&
-              std::is_nothrow_move_constructible<Alloc>::value)
+      std::is_nothrow_move_constructible<Hasher>::value &&
+      std::is_nothrow_move_constructible<KeyEqual>::value &&
+      std::is_nothrow_move_constructible<Alloc>::value)
       : Policy{std::move(rhs)} {
     swapContents(rhs);
   }
@@ -1296,8 +1296,8 @@ class F14Table : public Policy {
   }
 
   F14Table& operator=(F14Table&& rhs) noexcept(
-      std::is_nothrow_move_assignable<Hasher>::value&&
-          std::is_nothrow_move_assignable<KeyEqual>::value &&
+      std::is_nothrow_move_assignable<Hasher>::value &&
+      std::is_nothrow_move_assignable<KeyEqual>::value &&
       (kAllocIsAlwaysEqual ||
        (AllocTraits::propagate_on_container_move_assignment::value &&
         std::is_nothrow_move_assignable<Alloc>::value))) {
diff --git a/folly/container/heap_vector_types.h b/folly/container/heap_vector_types.h
index f9118e14353..7c3c622077b 100644
--- a/folly/container/heap_vector_types.h
+++ b/folly/container/heap_vector_types.h
@@ -1268,8 +1268,8 @@ class heap_vector_container : growth_policy_wrapper<GrowthPolicy> {
   }
 
   void swap(heap_vector_container& o) noexcept(
-      std::is_nothrow_swappable<Compare>::value&& noexcept(
-          std::declval<Container&>().swap(std::declval<Container&>()))) {
+      std::is_nothrow_swappable<Compare>::value &&
+      noexcept(std::declval<Container&>().swap(std::declval<Container&>()))) {
     using std::swap; // Allow ADL for swap(); fall back to std::swap().
     Compare& a = m_;
     Compare& b = o.m_;
@@ -1318,22 +1318,22 @@ class heap_vector_container : growth_policy_wrapper<GrowthPolicy> {
     explicit EBO(const value_compare& c, const Allocator& alloc) noexcept(
         std::is_nothrow_default_constructible<Container>::value)
         : value_compare(c), cont_(alloc) {}
-    EBO(const EBO& other, const Allocator& alloc)
-    noexcept(std::is_nothrow_constructible<
-             Container,
-             const Container&,
-             const Allocator&>::value)
+    EBO(const EBO& other, const Allocator& alloc) noexcept(
+        std::is_nothrow_constructible<
+            Container,
+            const Container&,
+            const Allocator&>::value)
         : value_compare(static_cast<const value_compare&>(other)),
           cont_(other.cont_, alloc) {}
-    EBO(EBO&& other, const Allocator& alloc)
-    noexcept(std::is_nothrow_constructible<
-             Container,
-             Container&&,
-             const Allocator&>::value)
+    EBO(EBO&& other, const Allocator& alloc) noexcept(
+        std::is_nothrow_constructible<
+            Container,
+            Container&&,
+            const Allocator&>::value)
         : value_compare(static_cast<value_compare&&>(other)),
           cont_(std::move(other.cont_), alloc) {}
-    EBO(const Compare& c, Container&& cont)
-    noexcept(std::is_nothrow_move_constructible<Container>::value)
+    EBO(const Compare& c, Container&& cont) noexcept(
+        std::is_nothrow_move_constructible<Container>::value)
         : value_compare(c), cont_(std::move(cont)) {}
     Container cont_;
   } m_;
diff --git a/folly/container/tape.h b/folly/container/tape.h
index ceca087d05a..7e8fb45dafc 100644
--- a/folly/container/tape.h
+++ b/folly/container/tape.h
@@ -231,9 +231,10 @@ class tape {
   }
 
   template <typename R>
-  auto push_back(R&& r) -> std::enable_if_t<
-      range_of_scalars<R> &&
-      !std::is_convertible_v<R, const_reference>> // handle \0 separately
+  auto push_back(R&& r)
+      -> std::enable_if_t<
+          range_of_scalars<R> &&
+          !std::is_convertible_v<R, const_reference>> // handle \0 separately
   {
     push_back(std::begin(r), std::end(r));
   }
@@ -264,9 +265,10 @@ class tape {
   }
 
   template <typename R>
-  auto push_back_unsafe(R&& r) -> std::enable_if_t<
-      range_of_scalars<R> &&
-      !std::is_convertible_v<R, const_reference>> // handle \0 separately
+  auto push_back_unsafe(R&& r)
+      -> std::enable_if_t<
+          range_of_scalars<R> &&
+          !std::is_convertible_v<R, const_reference>> // handle \0 separately
   {
     push_back_unsafe(std::begin(r), std::end(r));
   }
@@ -292,9 +294,10 @@ class tape {
       -> std::enable_if_t<iterator_of_scalars<I>, iterator>;
 
   template <typename R>
-  auto insert(const_iterator pos, R&& r) -> std::enable_if_t<
-      range_of_scalars<R> && !std::is_convertible_v<R, const_reference>,
-      iterator> {
+  auto insert(const_iterator pos, R&& r)
+      -> std::enable_if_t<
+          range_of_scalars<R> && !std::is_convertible_v<R, const_reference>,
+          iterator> {
     return insert(pos, std::begin(r), std::end(r));
   }
 
diff --git a/folly/container/test/F14MapTest.cpp b/folly/container/test/F14MapTest.cpp
index 9204e4054ae..d15aa6d2b54 100644
--- a/folly/container/test/F14MapTest.cpp
+++ b/folly/container/test/F14MapTest.cpp
@@ -1390,9 +1390,8 @@ TEST(F14VectorMap, destructuringErase) {
 
   resetTracking();
   m.erase(p1.first);
-  LOG(INFO) << "erase -> "
-            << "key_type ops " << Tracked<0>::counts() << ", mapped_type ops "
-            << Tracked<1>::counts();
+  LOG(INFO) << "erase -> " << "key_type ops " << Tracked<0>::counts()
+            << ", mapped_type ops " << Tracked<1>::counts();
   // deleting p1 will cause p2 to be moved to the front of the values array
   EXPECT_EQ(
       Tracked<0>::counts().dist(Counts{0, 1, 0, 0}) +
diff --git a/folly/container/test/F14SetTest.cpp b/folly/container/test/F14SetTest.cpp
index aa3cc800640..004e28bd926 100644
--- a/folly/container/test/F14SetTest.cpp
+++ b/folly/container/test/F14SetTest.cpp
@@ -1538,9 +1538,8 @@ void runRandomInsertOrderTest(F&& func) {
 TEST(F14Set, randomInsertOrder) {
   runRandomInsertOrderTest<F14ValueSet<char>>([](char x) { return x; });
   runRandomInsertOrderTest<F14FastSet<char>>([](char x) { return x; });
-  runRandomInsertOrderTest<F14FastSet<std::string>>([](char x) {
-    return std::string{std::size_t{1}, x};
-  });
+  runRandomInsertOrderTest<F14FastSet<std::string>>(
+      [](char x) { return std::string{std::size_t{1}, x}; });
 }
 
 template <template <class...> class TSet>
diff --git a/folly/container/test/ForeachBenchmark.cpp b/folly/container/test/ForeachBenchmark.cpp
index 7b1e69f4c2e..dda0d9beaa3 100644
--- a/folly/container/test/ForeachBenchmark.cpp
+++ b/folly/container/test/ForeachBenchmark.cpp
@@ -278,7 +278,9 @@ BENCHMARK(ForEachKVNoMacroAssign, iters) {
   int sumKeys = 0;
   std::string sumValues;
 
-  BENCHMARK_SUSPEND { setupBenchmark(iters); }
+  BENCHMARK_SUSPEND {
+    setupBenchmark(iters);
+  }
 
   FOR_EACH (iter, bmMap) {
     const int k = iter->first;
@@ -292,7 +294,9 @@ BENCHMARK(ForEachKVNoMacroNoAssign, iters) {
   int sumKeys = 0;
   std::string sumValues;
 
-  BENCHMARK_SUSPEND { setupBenchmark(iters); }
+  BENCHMARK_SUSPEND {
+    setupBenchmark(iters);
+  }
 
   FOR_EACH (iter, bmMap) {
     sumKeys += iter->first;
@@ -310,7 +314,9 @@ BENCHMARK(ForEachManual, iters) {
 
 BENCHMARK(ForEachRange, iters) {
   int sum = 1;
-  FOR_EACH_RANGE (i, 1, iters) { sum *= i; }
+  FOR_EACH_RANGE (i, 1, iters) {
+    sum *= i;
+  }
   doNotOptimizeAway(sum);
 }
 
@@ -323,7 +329,9 @@ BENCHMARK(ForEachDescendingManual, iters) {
 }
 
 BENCHMARK(CharVecForRange, iters) {
-  BENCHMARK_SUSPEND { setupCharVecBenchmark(iters); }
+  BENCHMARK_SUSPEND {
+    setupCharVecBenchmark(iters);
+  }
   size_t sum = 0;
   for (auto& c : vec_char) {
     sum += c;
@@ -332,7 +340,9 @@ BENCHMARK(CharVecForRange, iters) {
 }
 
 BENCHMARK(CharVecForRangeExplicitIndex, iters) {
-  BENCHMARK_SUSPEND { setupCharVecBenchmark(iters); }
+  BENCHMARK_SUSPEND {
+    setupCharVecBenchmark(iters);
+  }
   size_t sum = 0;
   size_t index = 0;
   for (auto& c : vec_char) {
@@ -343,21 +353,27 @@ BENCHMARK(CharVecForRangeExplicitIndex, iters) {
 }
 
 BENCHMARK(CharVecForEach, iters) {
-  BENCHMARK_SUSPEND { setupCharVecBenchmark(iters); }
+  BENCHMARK_SUSPEND {
+    setupCharVecBenchmark(iters);
+  }
   size_t sum = 0;
   folly::for_each(vec_char, [&](auto& c) { sum += c; });
   doNotOptimizeAway(sum);
 }
 
 BENCHMARK(CharVecForEachIndex, iters) {
-  BENCHMARK_SUSPEND { setupCharVecBenchmark(iters); }
+  BENCHMARK_SUSPEND {
+    setupCharVecBenchmark(iters);
+  }
   size_t sum = 0;
   folly::for_each(vec_char, [&](auto& c, auto index) { sum += c * index; });
   doNotOptimizeAway(sum);
 }
 
 BENCHMARK(CharVecForRangeEnumerate, iters) {
-  BENCHMARK_SUSPEND { setupCharVecBenchmark(iters); }
+  BENCHMARK_SUSPEND {
+    setupCharVecBenchmark(iters);
+  }
   size_t sum = 0;
   for (auto&& it : enumerate(vec_char)) {
     sum += *it * it.index;
diff --git a/folly/container/test/ForeachTest.cpp b/folly/container/test/ForeachTest.cpp
index 8e6f1f45a89..84b307e306d 100644
--- a/folly/container/test/ForeachTest.cpp
+++ b/folly/container/test/ForeachTest.cpp
@@ -314,7 +314,9 @@ TEST(ForEach, FetchTestPreferIterator) {
 TEST(Foreach, ForEachRvalue) {
   const char* const hello = "hello";
   int n = 0;
-  FOR_EACH (it, std::string(hello)) { ++n; }
+  FOR_EACH (it, std::string(hello)) {
+    ++n;
+  }
   EXPECT_EQ(strlen(hello), n);
   FOR_EACH_R (it, std::string(hello)) {
     --n;
@@ -327,7 +329,9 @@ TEST(Foreach, ForEachNested) {
   const std::string hello = "hello";
   size_t n = 0;
   FOR_EACH (i, hello) {
-    FOR_EACH (j, hello) { ++n; }
+    FOR_EACH (j, hello) {
+      ++n;
+    }
   }
   auto len = hello.size();
   EXPECT_EQ(len * len, n);
diff --git a/folly/container/test/HashMapsBench.cpp b/folly/container/test/HashMapsBench.cpp
index be030bf1099..f8e04ddd6c7 100644
--- a/folly/container/test/HashMapsBench.cpp
+++ b/folly/container/test/HashMapsBench.cpp
@@ -309,8 +309,7 @@ void benchmarkDtor(int runs, int size) {
 template <template <class, class> class Map, class K, class V>
 void benchmarkClear(int runs, int size) {
   for (int i = 0; i < runs; ++i) {
-    benchmarkFilledMap<Map, K, V>(
-        1, size, [&](Map<K, V>& m) { m.clear(); }, 1);
+    benchmarkFilledMap<Map, K, V>(1, size, [&](Map<K, V>& m) { m.clear(); }, 1);
   }
 }
 
@@ -318,8 +317,7 @@ template <template <class, class> class Map, class K, class V>
 void benchmarkCopyCtor(int runs, int size) {
   Map<K, V> n;
   for (int i = 0; i < runs; ++i) {
-    benchmarkFilledMap<Map, K, V>(
-        1, size, [&](Map<K, V>& m) { n = m; }, 1);
+    benchmarkFilledMap<Map, K, V>(1, size, [&](Map<K, V>& m) { n = m; }, 1);
     folly::doNotOptimizeAway(n);
   }
 }
diff --git a/folly/detail/MemoryIdler.cpp b/folly/detail/MemoryIdler.cpp
index 286eb185df8..bf218f2c530 100644
--- a/folly/detail/MemoryIdler.cpp
+++ b/folly/detail/MemoryIdler.cpp
@@ -128,7 +128,9 @@ static void fetchStackLimits() {
     tls_stackSize = 1;
     return;
   }
-  SCOPE_EXIT { pthread_attr_destroy(&attr); };
+  SCOPE_EXIT {
+    pthread_attr_destroy(&attr);
+  };
 
   void* addr;
   size_t rawSize;
diff --git a/folly/detail/ThreadLocalDetail.cpp b/folly/detail/ThreadLocalDetail.cpp
index 173c7c765e2..e18d78aa8cf 100644
--- a/folly/detail/ThreadLocalDetail.cpp
+++ b/folly/detail/ThreadLocalDetail.cpp
@@ -496,8 +496,8 @@ struct GlibcThreadLocalInit {
     compiler_must_not_elide(glibcThreadLocalInit);
   }
 };
-__attribute__((__init_priority__(101)))
-GlibcThreadLocalInit glibcThreadLocalInit;
+__attribute__((
+    __init_priority__(101))) GlibcThreadLocalInit glibcThreadLocalInit;
 #endif
 } // namespace threadlocal_detail
 } // namespace folly
diff --git a/folly/docs/examples/folly/ScopeGuard.cpp b/folly/docs/examples/folly/ScopeGuard.cpp
index 2d60c9330ba..841349194c2 100644
--- a/folly/docs/examples/folly/ScopeGuard.cpp
+++ b/folly/docs/examples/folly/ScopeGuard.cpp
@@ -29,7 +29,9 @@ TEST(scopeGuard, demo) {
 TEST(scopeExit, demo) {
   int y = 0;
   {
-    SCOPE_EXIT { y = 1234; };
+    SCOPE_EXIT {
+      y = 1234;
+    };
     EXPECT_EQ(y, 0);
   }
   EXPECT_EQ(y, 1234);
diff --git a/folly/executors/EDFThreadPoolExecutor.cpp b/folly/executors/EDFThreadPoolExecutor.cpp
index 61b861cc715..6831bfe5e27 100644
--- a/folly/executors/EDFThreadPoolExecutor.cpp
+++ b/folly/executors/EDFThreadPoolExecutor.cpp
@@ -430,7 +430,9 @@ std::shared_ptr<EDFThreadPoolExecutor::Task> EDFThreadPoolExecutor::take() {
   // No tasks on the horizon, so go sleep
   numIdleThreads_.fetch_add(1, std::memory_order_seq_cst);
 
-  SCOPE_EXIT { numIdleThreads_.fetch_sub(1, std::memory_order_seq_cst); };
+  SCOPE_EXIT {
+    numIdleThreads_.fetch_sub(1, std::memory_order_seq_cst);
+  };
 
   for (;;) {
     if (FOLLY_UNLIKELY(shouldStop())) {
diff --git a/folly/executors/thread_factory/InitThreadFactory.h b/folly/executors/thread_factory/InitThreadFactory.h
index 34caf26f984..81e6e2cc5da 100644
--- a/folly/executors/thread_factory/InitThreadFactory.h
+++ b/folly/executors/thread_factory/InitThreadFactory.h
@@ -38,7 +38,9 @@ class InitThreadFactory : public ThreadFactory {
     return threadFactory_->newThread(
         [func = std::move(func), threadInitFini = threadInitFini_]() mutable {
           threadInitFini->initializer();
-          SCOPE_EXIT { threadInitFini->finalizer(); };
+          SCOPE_EXIT {
+            threadInitFini->finalizer();
+          };
           func();
         });
   }
diff --git a/folly/experimental/Cleanup.h b/folly/experimental/Cleanup.h
index e88ca08ac5a..a4c2d8935c8 100644
--- a/folly/experimental/Cleanup.h
+++ b/folly/experimental/Cleanup.h
@@ -39,7 +39,7 @@ struct cleanup_fn {
       std::enable_if_t<std::is_same_v<R, folly::SemiFuture<folly::Unit>>, int> =
           0>
   R operator()(T&& t) const {
-    return ((T &&) t).cleanup();
+    return ((T&&)t).cleanup();
   }
 };
 } // namespace detail
@@ -166,7 +166,7 @@ class Cleanup {
       class OtherCleanup,
       std::enable_if_t<is_cleanup_v<OtherCleanup>, int> = 0>
   void addCleanup(OtherCleanup&& c) {
-    addCleanup(((OtherCleanup &&) c).cleanup());
+    addCleanup(((OtherCleanup&&)c).cleanup());
   }
 
  private:
diff --git a/folly/experimental/JemallocHugePageAllocator.cpp b/folly/experimental/JemallocHugePageAllocator.cpp
index 200bc44fa3d..89684d42873 100644
--- a/folly/experimental/JemallocHugePageAllocator.cpp
+++ b/folly/experimental/JemallocHugePageAllocator.cpp
@@ -47,8 +47,13 @@ bool folly::JemallocHugePageAllocator::hugePagesSupported{true};
 
 #if !defined(JEMALLOC_VERSION_MAJOR) || (JEMALLOC_VERSION_MAJOR < 5)
 typedef struct extent_hooks_s extent_hooks_t;
-typedef void*(
-    extent_alloc_t)(extent_hooks_t*, void*, size_t, size_t, bool*, bool*, unsigned);
+typedef void*(extent_alloc_t)(extent_hooks_t*,
+                              void*,
+                              size_t,
+                              size_t,
+                              bool*,
+                              bool*,
+                              unsigned);
 struct extent_hooks_s {
   extent_alloc_t* alloc;
 };
diff --git a/folly/experimental/LockFreeRingBuffer.h b/folly/experimental/LockFreeRingBuffer.h
index 573c131090d..4a617b6b07c 100644
--- a/folly/experimental/LockFreeRingBuffer.h
+++ b/folly/experimental/LockFreeRingBuffer.h
@@ -296,7 +296,7 @@ class [[deprecated(
  public:
   void store(const T& src) { data_ = src; }
 
-  void load(T & dest) const { dest = data_; }
+  void load(T& dest) const { dest = data_; }
 
  private:
   T data_{};
diff --git a/folly/experimental/QuotientMultiSet-inl.h b/folly/experimental/QuotientMultiSet-inl.h
index f7e294d1e52..1c271388768 100644
--- a/folly/experimental/QuotientMultiSet-inl.h
+++ b/folly/experimental/QuotientMultiSet-inl.h
@@ -250,8 +250,8 @@ auto QuotientMultiSet<Instructions>::equalRange(uint64_t key) const
 
 template <class Instructions>
 auto QuotientMultiSet<Instructions>::findRunend(
-    uint64_t occupiedRank, uint64_t firstRunend) const
-    -> std::pair<uint64_t, const Block*> {
+    uint64_t occupiedRank,
+    uint64_t firstRunend) const -> std::pair<uint64_t, const Block*> {
   // Look for the right runend.
   size_t slotBlockIndex = firstRunend / kBlockSize;
   auto block = getBlock(slotBlockIndex);
diff --git a/folly/experimental/TLRefCount.h b/folly/experimental/TLRefCount.h
index 40145712578..f0c24c72a45 100644
--- a/folly/experimental/TLRefCount.h
+++ b/folly/experimental/TLRefCount.h
@@ -188,7 +188,9 @@ class TLRefCount {
       // fetch_add on platforms with native support.
       auto count = count_.load(std::memory_order_relaxed) + delta;
       inUpdate_.store(true, std::memory_order_relaxed);
-      SCOPE_EXIT { inUpdate_.store(false, std::memory_order_release); };
+      SCOPE_EXIT {
+        inUpdate_.store(false, std::memory_order_release);
+      };
       count_.store(count, std::memory_order_release);
 
       asymmetric_thread_fence_light(std::memory_order_seq_cst);
diff --git a/folly/experimental/TestUtil.h b/folly/experimental/TestUtil.h
index 1e0f92d50fb..65f768e02bf 100644
--- a/folly/experimental/TestUtil.h
+++ b/folly/experimental/TestUtil.h
@@ -157,7 +157,9 @@ void enableInvalidParameters(SavedState state);
 template <typename Func>
 auto msvcSuppressAbortOnInvalidParams(Func func) -> decltype(func()) {
   auto savedState = detail::disableInvalidParameters();
-  SCOPE_EXIT { detail::enableInvalidParameters(savedState); };
+  SCOPE_EXIT {
+    detail::enableInvalidParameters(savedState);
+  };
   return func();
 }
 
diff --git a/folly/experimental/TupleOps.h b/folly/experimental/TupleOps.h
index d6cbd17c31a..5b03146ed82 100644
--- a/folly/experimental/TupleOps.h
+++ b/folly/experimental/TupleOps.h
@@ -72,9 +72,10 @@ template <
     std::size_t start = 0,
     std::size_t count = std::numeric_limits<std::size_t>::max(),
     typename tup>
-auto tupleRange(tup&& t) -> decltype(detail::tuple_ops_range_of_(
-    static_cast<tup&&>(t),
-    detail::tuple_ops_range_of_seq<start, count, tup>{})) {
+auto tupleRange(tup&& t)
+    -> decltype(detail::tuple_ops_range_of_(
+        static_cast<tup&&>(t),
+        detail::tuple_ops_range_of_seq<start, count, tup>{})) {
   return detail::tuple_ops_range_of_(
       static_cast<tup&&>(t),
       detail::tuple_ops_range_of_seq<start, count, tup>{});
@@ -83,7 +84,8 @@ auto tupleRange(tup&& t) -> decltype(detail::tuple_ops_range_of_(
 // Return a tuple obtained by prepending car to the tuple cdr.
 template <class T, class U>
 auto tuplePrepend(T&& car, U&& cdr) -> decltype(std::tuple_cat(
-    std::make_tuple(std::forward<T>(car)), std::forward<U>(cdr))) {
+                                        std::make_tuple(std::forward<T>(car)),
+                                        std::forward<U>(cdr))) {
   return std::tuple_cat(
       std::make_tuple(std::forward<T>(car)), std::forward<U>(cdr));
 }
diff --git a/folly/experimental/channels/test/MergeChannelTest.cpp b/folly/experimental/channels/test/MergeChannelTest.cpp
index 7306fd52693..69eeefbf9a7 100644
--- a/folly/experimental/channels/test/MergeChannelTest.cpp
+++ b/folly/experimental/channels/test/MergeChannelTest.cpp
@@ -477,9 +477,7 @@ class MergeChannelFixtureStress : public Test {
   static std::unique_ptr<StressTestProducer<ProducedValue>> makeProducer(
       int index) {
     return std::make_unique<StressTestProducer<ProducedValue>>(
-        [index, value = 0]() mutable {
-          return ProducedValue{index, value++};
-        });
+        [index, value = 0]() mutable { return ProducedValue{index, value++}; });
   }
 
   static std::unique_ptr<
diff --git a/folly/experimental/channels/test/MergeTest.cpp b/folly/experimental/channels/test/MergeTest.cpp
index f7e33be7271..a444b2e7fc9 100644
--- a/folly/experimental/channels/test/MergeTest.cpp
+++ b/folly/experimental/channels/test/MergeTest.cpp
@@ -246,9 +246,7 @@ class MergeFixtureStress : public Test {
   static std::unique_ptr<StressTestProducer<ProducedValue>> makeProducer(
       int index) {
     return std::make_unique<StressTestProducer<ProducedValue>>(
-        [index, value = 0]() mutable {
-          return ProducedValue{index, value++};
-        });
+        [index, value = 0]() mutable { return ProducedValue{index, value++}; });
   }
 
   static std::unique_ptr<StressTestConsumer<ProducedValue>> makeConsumer() {
diff --git a/folly/experimental/coro/AsyncGenerator.h b/folly/experimental/coro/AsyncGenerator.h
index 4ff0962680b..83622ae6f14 100644
--- a/folly/experimental/coro/AsyncGenerator.h
+++ b/folly/experimental/coro/AsyncGenerator.h
@@ -247,7 +247,9 @@ class FOLLY_NODISCARD AsyncGenerator {
   CleanupSemiAwaitable cleanup() && {
     static_assert(RequiresCleanup);
     if (coro_) {
-      SCOPE_EXIT { std::exchange(coro_, {}).destroy(); };
+      SCOPE_EXIT {
+        std::exchange(coro_, {}).destroy();
+      };
       return CleanupSemiAwaitable{coro_.promise().scopeExit_};
     } else {
       return CleanupSemiAwaitable{{}};
diff --git a/folly/experimental/coro/Collect-inl.h b/folly/experimental/coro/Collect-inl.h
index 9e248d9cac9..4187e56eb3a 100644
--- a/folly/experimental/coro/Collect-inl.h
+++ b/folly/experimental/coro/Collect-inl.h
@@ -387,8 +387,9 @@ auto collectAnyNoDiscardImpl(
 } // namespace detail
 
 template <typename... SemiAwaitables>
-auto collectAll(SemiAwaitables&&... awaitables) -> folly::coro::Task<std::tuple<
-    detail::collect_all_component_t<remove_cvref_t<SemiAwaitables>>...>> {
+auto collectAll(SemiAwaitables&&... awaitables)
+    -> folly::coro::Task<std::tuple<
+        detail::collect_all_component_t<remove_cvref_t<SemiAwaitables>>...>> {
   return detail::collectAllImpl(
       std::make_index_sequence<sizeof...(SemiAwaitables)>{},
       static_cast<SemiAwaitables&&>(awaitables)...);
@@ -1051,10 +1052,11 @@ auto collectAnyNoDiscard(SemiAwaitables&&... awaitables)
 }
 
 template <typename InputRange>
-auto collectAnyRange(InputRange awaitables) -> folly::coro::Task<std::pair<
-    size_t,
-    folly::Try<detail::collect_all_range_component_t<
-        detail::range_reference_t<InputRange>>>>> {
+auto collectAnyRange(InputRange awaitables)
+    -> folly::coro::Task<std::pair<
+        size_t,
+        folly::Try<detail::collect_all_range_component_t<
+            detail::range_reference_t<InputRange>>>>> {
   const CancellationToken& parentCancelToken =
       co_await co_current_cancellation_token;
   const CancellationSource cancelSource;
diff --git a/folly/experimental/coro/Collect.h b/folly/experimental/coro/Collect.h
index 1e293496109..797d3a44ec0 100644
--- a/folly/experimental/coro/Collect.h
+++ b/folly/experimental/coro/Collect.h
@@ -122,8 +122,9 @@ class MoveRange {
 //       co_await folly::coro::collectAll(doSomething(), doSomethingElse());
 //
 template <typename... SemiAwaitables>
-auto collectAll(SemiAwaitables&&... awaitables) -> folly::coro::Task<std::tuple<
-    detail::collect_all_component_t<remove_cvref_t<SemiAwaitables>>...>>;
+auto collectAll(SemiAwaitables&&... awaitables)
+    -> folly::coro::Task<std::tuple<
+        detail::collect_all_component_t<remove_cvref_t<SemiAwaitables>>...>>;
 
 ///////////////////////////////////////////////////////////////////////////
 // collectAllTry(SemiAwaitable<Ts>...)
@@ -539,10 +540,11 @@ auto collectAnyNoDiscard(SemiAwaitables&&... awaitables)
 //       ranges::views::move);
 //
 template <typename InputRange>
-auto collectAnyRange(InputRange awaitables) -> folly::coro::Task<std::pair<
-    size_t,
-    folly::Try<detail::collect_all_range_component_t<
-        detail::range_reference_t<InputRange>>>>>;
+auto collectAnyRange(InputRange awaitables)
+    -> folly::coro::Task<std::pair<
+        size_t,
+        folly::Try<detail::collect_all_range_component_t<
+            detail::range_reference_t<InputRange>>>>>;
 
 ///////////////////////////////////////////////////////////////////////////
 // collectAnyWithoutExceptionRange(RangeOf<SemiAwaitable<T>>&&)
diff --git a/folly/experimental/coro/ScopeExit.h b/folly/experimental/coro/ScopeExit.h
index 0f7fbbaf227..5b34c0037d4 100644
--- a/folly/experimental/coro/ScopeExit.h
+++ b/folly/experimental/coro/ScopeExit.h
@@ -91,7 +91,9 @@ class ScopeExitTaskPromiseBase {
     template <typename Promise>
     FOLLY_CORO_AWAIT_SUSPEND_NONTRIVIAL_ATTRIBUTES coroutine_handle<>
     await_suspend(coroutine_handle<Promise> coro) noexcept {
-      SCOPE_EXIT { coro.destroy(); };
+      SCOPE_EXIT {
+        coro.destroy();
+      };
 
       ScopeExitTaskPromiseBase& promise = coro.promise();
       DCHECK(promise.continuation_);
diff --git a/folly/experimental/coro/SmallUnboundedQueue.h b/folly/experimental/coro/SmallUnboundedQueue.h
index 156a3ac2d67..659fdc8f625 100644
--- a/folly/experimental/coro/SmallUnboundedQueue.h
+++ b/folly/experimental/coro/SmallUnboundedQueue.h
@@ -79,7 +79,9 @@ class SmallUnboundedQueue : detail::SmallUnboundedQueueBase<!SingleConsumer> {
       buffer_ = queue_.getMessages();
       DCHECK(!buffer_.empty());
     }
-    SCOPE_EXIT { buffer_.pop(); };
+    SCOPE_EXIT {
+      buffer_.pop();
+    };
     co_return std::move(buffer_.front());
   }
 
diff --git a/folly/experimental/coro/Task.h b/folly/experimental/coro/Task.h
index 3496b8d17b7..c6007da5ab1 100644
--- a/folly/experimental/coro/Task.h
+++ b/folly/experimental/coro/Task.h
@@ -539,12 +539,16 @@ class FOLLY_NODISCARD TaskWithExecutor {
     T await_resume() {
       DCHECK(coro_);
       // Eagerly destroy the coroutine-frame once we have retrieved the result.
-      SCOPE_EXIT { std::exchange(coro_, {}).destroy(); };
+      SCOPE_EXIT {
+        std::exchange(coro_, {}).destroy();
+      };
       return std::move(coro_.promise().result()).value();
     }
 
     folly::Try<StorageType> await_resume_try() {
-      SCOPE_EXIT { std::exchange(coro_, {}).destroy(); };
+      SCOPE_EXIT {
+        std::exchange(coro_, {}).destroy();
+      };
       return std::move(coro_.promise().result());
     }
 
@@ -593,7 +597,9 @@ class FOLLY_NODISCARD TaskWithExecutor {
     folly::Try<StorageType> await_resume() {
       DCHECK(coro_);
       // Eagerly destroy the coroutine-frame once we have retrieved the result.
-      SCOPE_EXIT { std::exchange(coro_, {}).destroy(); };
+      SCOPE_EXIT {
+        std::exchange(coro_, {}).destroy();
+      };
       return std::move(coro_.promise().result());
     }
 
@@ -818,13 +824,17 @@ class FOLLY_NODISCARD Task {
 
     T await_resume() {
       DCHECK(coro_);
-      SCOPE_EXIT { std::exchange(coro_, {}).destroy(); };
+      SCOPE_EXIT {
+        std::exchange(coro_, {}).destroy();
+      };
       return std::move(coro_.promise().result()).value();
     }
 
     folly::Try<StorageType> await_resume_try() {
       DCHECK(coro_);
-      SCOPE_EXIT { std::exchange(coro_, {}).destroy(); };
+      SCOPE_EXIT {
+        std::exchange(coro_, {}).destroy();
+      };
       return std::move(coro_.promise().result());
     }
 
diff --git a/folly/experimental/coro/ViaIfAsync.h b/folly/experimental/coro/ViaIfAsync.h
index ea89ac91e22..935b56dad21 100644
--- a/folly/experimental/coro/ViaIfAsync.h
+++ b/folly/experimental/coro/ViaIfAsync.h
@@ -633,7 +633,7 @@ class TryAwaitable : public CommutativeWrapperAwaitable<TryAwaitable, T> {
           int> = 0,
       typename T2 = like_t<Self, T>,
       std::enable_if_t<is_awaitable_v<T2>, int> = 0>
-  friend TryAwaiter<T2> operator co_await(Self&& self) {
+  friend TryAwaiter<T2> operator co_await(Self && self) {
     return TryAwaiter<T2>{static_cast<Self&&>(self).inner_};
   }
 };
diff --git a/folly/experimental/coro/WithCancellation.h b/folly/experimental/coro/WithCancellation.h
index fd34c3941b3..682c20de9ab 100644
--- a/folly/experimental/coro/WithCancellation.h
+++ b/folly/experimental/coro/WithCancellation.h
@@ -41,7 +41,7 @@ namespace adl {
 template <typename Awaitable>
 Awaitable&& co_withCancellation(
     const folly::CancellationToken&, Awaitable&& awaitable) noexcept {
-  return (Awaitable &&) awaitable;
+  return (Awaitable&&)awaitable;
 }
 
 struct WithCancellationFunction {
@@ -49,20 +49,19 @@ struct WithCancellationFunction {
   auto operator()(
       const folly::CancellationToken& cancelToken, Awaitable&& awaitable) const
       noexcept(
-          noexcept(co_withCancellation(cancelToken, (Awaitable &&) awaitable)))
+          noexcept(co_withCancellation(cancelToken, (Awaitable&&)awaitable)))
           -> decltype(co_withCancellation(
-              cancelToken, (Awaitable &&) awaitable)) {
-    return co_withCancellation(cancelToken, (Awaitable &&) awaitable);
+              cancelToken, (Awaitable&&)awaitable)) {
+    return co_withCancellation(cancelToken, (Awaitable&&)awaitable);
   }
 
   template <typename Awaitable>
   auto operator()(folly::CancellationToken&& cancelToken, Awaitable&& awaitable)
-      const noexcept(noexcept(co_withCancellation(
-          std::move(cancelToken), (Awaitable &&) awaitable)))
+      const noexcept(noexcept(
+          co_withCancellation(std::move(cancelToken), (Awaitable&&)awaitable)))
           -> decltype(co_withCancellation(
-              std::move(cancelToken), (Awaitable &&) awaitable)) {
-    return co_withCancellation(
-        std::move(cancelToken), (Awaitable &&) awaitable);
+              std::move(cancelToken), (Awaitable&&)awaitable)) {
+    return co_withCancellation(std::move(cancelToken), (Awaitable&&)awaitable);
   }
 };
 } // namespace adl
diff --git a/folly/experimental/coro/test/AsyncGeneratorTest.cpp b/folly/experimental/coro/test/AsyncGeneratorTest.cpp
index 1300c176050..4745b5d2513 100644
--- a/folly/experimental/coro/test/AsyncGeneratorTest.cpp
+++ b/folly/experimental/coro/test/AsyncGeneratorTest.cpp
@@ -66,7 +66,9 @@ TEST_F(AsyncGeneratorTest, PartiallyConsumingSequenceDestroysObjectsInScope) {
   bool started = false;
   bool destroyed = false;
   auto makeGenerator = [&]() -> folly::coro::AsyncGenerator<int> {
-    SCOPE_EXIT { destroyed = true; };
+    SCOPE_EXIT {
+      destroyed = true;
+    };
     started = true;
     co_yield 1;
     co_yield 2;
diff --git a/folly/experimental/coro/test/BlockingWaitTest.cpp b/folly/experimental/coro/test/BlockingWaitTest.cpp
index ed2d49c1fb7..9581fd9ec5b 100644
--- a/folly/experimental/coro/test/BlockingWaitTest.cpp
+++ b/folly/experimental/coro/test/BlockingWaitTest.cpp
@@ -128,7 +128,9 @@ TEST_F(BlockingWaitTest, ReturnRvalueReferenceFromAwaiter) {
 TEST_F(BlockingWaitTest, AsynchronousCompletionOnAnotherThread) {
   folly::coro::Baton baton;
   std::thread t{[&] { baton.post(); }};
-  SCOPE_EXIT { t.join(); };
+  SCOPE_EXIT {
+    t.join();
+  };
   folly::coro::blockingWait(baton);
 }
 
@@ -176,7 +178,9 @@ class SimplePromise {
 TEST_F(BlockingWaitTest, WaitOnSimpleAsyncPromise) {
   SimplePromise<std::string> p;
   std::thread t{[&] { p.emplace("hello coroutines!"); }};
-  SCOPE_EXIT { t.join(); };
+  SCOPE_EXIT {
+    t.join();
+  };
   auto result = folly::coro::blockingWait(p);
   EXPECT_EQ("hello coroutines!", result);
 }
@@ -191,7 +195,9 @@ struct MoveCounting {
 TEST_F(BlockingWaitTest, WaitOnMoveOnlyAsyncPromise) {
   SimplePromise<MoveCounting> p;
   std::thread t{[&] { p.emplace(); }};
-  SCOPE_EXIT { t.join(); };
+  SCOPE_EXIT {
+    t.join();
+  };
   auto result = folly::coro::blockingWait(p);
 
   // Number of move-constructions:
diff --git a/folly/experimental/coro/test/GeneratorTest.cpp b/folly/experimental/coro/test/GeneratorTest.cpp
index f23c88c4845..0bd337d87be 100644
--- a/folly/experimental/coro/test/GeneratorTest.cpp
+++ b/folly/experimental/coro/test/GeneratorTest.cpp
@@ -106,7 +106,9 @@ TEST_F(GeneratorTest, DestroyedBeforeCompletion_DestructsObjectsOnStack) {
   bool destructed = false;
   bool completed = false;
   auto f = [&]() -> Generator<std::uint32_t> {
-    SCOPE_EXIT { destructed = true; };
+    SCOPE_EXIT {
+      destructed = true;
+    };
 
     co_yield 1;
     co_yield 2;
diff --git a/folly/experimental/coro/test/MergeTest.cpp b/folly/experimental/coro/test/MergeTest.cpp
index 7086fe7da69..e8dc479f2bf 100644
--- a/folly/experimental/coro/test/MergeTest.cpp
+++ b/folly/experimental/coro/test/MergeTest.cpp
@@ -74,7 +74,9 @@ TEST_F(MergeTest, TruncateStream) {
           co_invoke([&]() -> AsyncGenerator<AsyncGenerator<int>> {
             auto makeGenerator = [&]() -> AsyncGenerator<int> {
               ++started;
-              SCOPE_EXIT { ++completed; };
+              SCOPE_EXIT {
+                ++completed;
+              };
               co_yield 1;
               co_await co_reschedule_on_current_executor;
               co_yield 2;
@@ -282,7 +284,9 @@ TEST_F(MergeTest, SourcesAreDestroyedBeforeEof) {
   auto sourceGenerator =
       [&](bool shouldThrow) -> folly::coro::AsyncGenerator<int> {
     ++runningSourceGenerators;
-    SCOPE_EXIT { --runningSourceGenerators; };
+    SCOPE_EXIT {
+      --runningSourceGenerators;
+    };
     co_await folly::coro::co_reschedule_on_current_executor;
     co_yield 42;
     co_await folly::coro::co_reschedule_on_current_executor;
diff --git a/folly/experimental/coro/test/TaskTest.cpp b/folly/experimental/coro/test/TaskTest.cpp
index a2a16352c69..942386aaf23 100644
--- a/folly/experimental/coro/test/TaskTest.cpp
+++ b/folly/experimental/coro/test/TaskTest.cpp
@@ -727,11 +727,17 @@ TEST_F(TaskTest, CoAwaitNothrowDestructorOrdering) {
   int i = 0;
   folly::coro::blockingWait(co_awaitTry([&]() -> folly::coro::Task<> {
     co_await folly::coro::co_nothrow([&]() -> folly::coro::Task<> {
-      SCOPE_EXIT { i *= i; };
+      SCOPE_EXIT {
+        i *= i;
+      };
       co_await folly::coro::co_nothrow([&]() -> folly::coro::Task<> {
-        SCOPE_EXIT { i *= 3; };
+        SCOPE_EXIT {
+          i *= 3;
+        };
         co_await folly::coro::co_nothrow([&]() -> folly::coro::Task<> {
-          SCOPE_EXIT { i += 1; };
+          SCOPE_EXIT {
+            i += 1;
+          };
           co_return;
         }());
       }());
@@ -751,7 +757,9 @@ TEST_F(TaskTest, CoYieldCoErrorSameExecutor) {
     auto eb = dynamic_cast<folly::EventBase*>(
         co_await folly::coro::co_current_executor);
     CHECK(eb);
-    SCOPE_EXIT { CHECK(eb->inRunningEventBaseThread()); };
+    SCOPE_EXIT {
+      CHECK(eb->inRunningEventBaseThread());
+    };
     co_yield folly::coro::co_error(ExpectedException());
   };
   auto scopeAndThrowWrapper = [&]() -> folly::coro::Task<void> {
diff --git a/folly/experimental/crypto/test/Blake2xbBenchmark.cpp b/folly/experimental/crypto/test/Blake2xbBenchmark.cpp
index d002cb5c7a8..12e48fd319e 100644
--- a/folly/experimental/crypto/test/Blake2xbBenchmark.cpp
+++ b/folly/experimental/crypto/test/Blake2xbBenchmark.cpp
@@ -32,7 +32,9 @@ using namespace ::folly::crypto;
 void benchmarkBlake2b(size_t inputSize, size_t n) {
   std::array<uint8_t, crypto_generichash_blake2b_BYTES_MAX> result;
   std::vector<uint8_t> input;
-  BENCHMARK_SUSPEND { input.resize(inputSize); };
+  BENCHMARK_SUSPEND {
+    input.resize(inputSize);
+  };
   for (size_t i = 0; i < static_cast<size_t>(n); ++i) {
     int res = crypto_generichash_blake2b(
         result.data(), sizeof(result), input.data(), input.size(), nullptr, 0);
diff --git a/folly/experimental/exception_tracer/SmartExceptionStackTraceHooks.cpp b/folly/experimental/exception_tracer/SmartExceptionStackTraceHooks.cpp
index e6eb109237e..7bc9f3abda1 100644
--- a/folly/experimental/exception_tracer/SmartExceptionStackTraceHooks.cpp
+++ b/folly/experimental/exception_tracer/SmartExceptionStackTraceHooks.cpp
@@ -52,7 +52,9 @@ void throwCallback(
   if (handlingThrow) {
     return;
   }
-  SCOPE_EXIT { handlingThrow = false; };
+  SCOPE_EXIT {
+    handlingThrow = false;
+  };
   handlingThrow = true;
 
   // This can allocate memory potentially causing problems in an OOM
diff --git a/folly/experimental/io/IoUring.h b/folly/experimental/io/IoUring.h
index f52c4f995b6..9e1d1592587 100644
--- a/folly/experimental/io/IoUring.h
+++ b/folly/experimental/io/IoUring.h
@@ -84,9 +84,7 @@ class IoUringOp : public AsyncBaseOp {
 
   void initBase() { init(); }
 
-  struct io_uring_sqe& getSqe() {
-    return sqe_.sqe;
-  }
+  struct io_uring_sqe& getSqe() { return sqe_.sqe; }
 
   size_t getSqeSize() const {
     return options_.sqe128 ? 128 : sizeof(struct io_uring_sqe);
diff --git a/folly/experimental/io/IoUringBackend.cpp b/folly/experimental/io/IoUringBackend.cpp
index 0fa30f82c2c..1b90ba4310e 100644
--- a/folly/experimental/io/IoUringBackend.cpp
+++ b/folly/experimental/io/IoUringBackend.cpp
@@ -409,9 +409,8 @@ IoUringFdRegistrationRecord* IoUringBackend::FdRegistry::alloc(
     // this usually happens when we hit the file desc limit
     // and retrying this operation for every request is expensive
     err_ = true;
-    LOG(ERROR) << "io_uring_register_files(1) "
-               << "failed errno = " << errno << ":\"" << folly::errnoStr(errno)
-               << "\" " << this;
+    LOG(ERROR) << "io_uring_register_files(1) " << "failed errno = " << errno
+               << ":\"" << folly::errnoStr(errno) << "\" " << this;
     return nullptr;
   }
 
@@ -954,7 +953,9 @@ void IoUringBackend::processPollIo(
   if (ev) {
     if (flags & IORING_CQE_F_MORE) {
       ioSqe->useCount_++;
-      SCOPE_EXIT { ioSqe->useCount_--; };
+      SCOPE_EXIT {
+        ioSqe->useCount_--;
+      };
       if (ioSqe->cbData_.processCb(this, res, flags)) {
         return;
       }
@@ -1427,7 +1428,9 @@ size_t IoUringBackend::getActiveEvents(WaitForEventsMode waitForEvents) {
   struct io_uring_cqe* cqe;
 
   setGetActiveEvents();
-  SCOPE_EXIT { doneGetActiveEvents(); };
+  SCOPE_EXIT {
+    doneGetActiveEvents();
+  };
 
   auto inner_do_wait = [&]() -> int {
     if (waitingToSubmit_) {
@@ -1931,7 +1934,9 @@ static bool doKernelSupportsSendZC() {
         << "doKernelSupportsSendZC: Unexpectedly io_uring_queue_init failed";
     return false;
   }
-  SCOPE_EXIT { io_uring_queue_exit(&ring); };
+  SCOPE_EXIT {
+    io_uring_queue_exit(&ring);
+  };
 
   auto* sqe = ::io_uring_get_sqe(&ring);
   if (!sqe) {
diff --git a/folly/experimental/io/IoUringBackend.h b/folly/experimental/io/IoUringBackend.h
index 0a632f9b639..2dd80c2c43b 100644
--- a/folly/experimental/io/IoUringBackend.h
+++ b/folly/experimental/io/IoUringBackend.h
@@ -227,12 +227,8 @@ class IoUringBackend : public EventBaseBackendBase {
   bool isWaitingToSubmit() const {
     return waitingToSubmit_ || !submitList_.empty();
   }
-  struct io_uring* ioRingPtr() {
-    return &ioRing_;
-  }
-  struct io_uring_params const& params() const {
-    return params_;
-  }
+  struct io_uring* ioRingPtr() { return &ioRing_; }
+  struct io_uring_params const& params() const { return params_; }
   bool useReqBatching() const {
     return options_.timeout.count() > 0 && options_.batchSize > 0;
   }
diff --git a/folly/experimental/io/IoUringProvidedBufferRing.h b/folly/experimental/io/IoUringProvidedBufferRing.h
index b7498b60507..503050da565 100644
--- a/folly/experimental/io/IoUringProvidedBufferRing.h
+++ b/folly/experimental/io/IoUringProvidedBufferRing.h
@@ -76,9 +76,7 @@ class IoUringProvidedBufferRing : public IoUringBufferProviderBase {
       return 1LLU << std::max<int>(5, bufferShift);
     }
 
-    struct io_uring_buf_ring* ring() const noexcept {
-      return ringPtr_;
-    }
+    struct io_uring_buf_ring* ring() const noexcept { return ringPtr_; }
 
     struct io_uring_buf* ringBuf(int idx) const noexcept {
       return &ringPtr_->bufs[idx & ringMask_];
diff --git a/folly/experimental/io/test/AsyncBaseTestLib.h b/folly/experimental/io/test/AsyncBaseTestLib.h
index 6391f2703c6..88686c39cb6 100644
--- a/folly/experimental/io/test/AsyncBaseTestLib.h
+++ b/folly/experimental/io/test/AsyncBaseTestLib.h
@@ -87,7 +87,9 @@ void testReadsSerially(
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDONLY);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   for (size_t i = 0; i < specs.size(); i++) {
     auto buf = TestUtil::allocateAligned(specs[i].size);
@@ -126,7 +128,9 @@ void testReadsParallel(
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDONLY);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   std::vector<std::thread> threads;
   if (multithreaded) {
@@ -197,7 +201,9 @@ void testReadsQueued(
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDONLY);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
   for (size_t i = 0; i < specs.size(); i++) {
     bufs.push_back(TestUtil::allocateAligned(specs[i].size));
     ops[i].pread(fd, bufs[i].get(), specs[i].size, specs[i].start);
@@ -389,7 +395,9 @@ TYPED_TEST_P(AsyncTest, NonBlockingWait) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDONLY);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
   size_t size = 2 * test::async_base_test_lib_detail::kODirectAlign;
   auto buf = test::async_base_test_lib_detail::TestUtil::allocateAligned(size);
   op.pread(fd, buf.get(), size, 0);
@@ -421,7 +429,9 @@ TYPED_TEST_P(AsyncTest, Cancel) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDONLY);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   size_t completed = 0;
 
@@ -487,7 +497,9 @@ TYPED_TEST_P(AsyncBatchTest, BatchRead) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDONLY);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   using OpPtr = folly::AsyncBaseOp*;
   std::unique_ptr<typename TypeParam::Op[]> ops(
diff --git a/folly/experimental/io/test/IoUringBackendTest.cpp b/folly/experimental/io/test/IoUringBackendTest.cpp
index 91087fa2cfb..c262ac52a41 100644
--- a/folly/experimental/io/test/IoUringBackendTest.cpp
+++ b/folly/experimental/io/test/IoUringBackendTest.cpp
@@ -675,7 +675,9 @@ TEST(IoUringBackend, OpenAtAbsolutePath) {
   auto path = folly::fs::unique_path();
   auto filePath = dirPath / path;
 
-  SCOPE_EXIT { ::unlink(filePath.string().c_str()); };
+  SCOPE_EXIT {
+    ::unlink(filePath.string().c_str());
+  };
 
   folly::IoUringBackend::FileOpCallback openCb = [&](int res) {
     evbPtr->terminateLoopSoon();
@@ -933,7 +935,9 @@ TEST(IoUringBackend, RegisteredFds) {
   int eventFd = ::eventfd(0, EFD_CLOEXEC | EFD_SEMAPHORE | EFD_NONBLOCK);
   CHECK_GT(eventFd, 0);
 
-  SCOPE_EXIT { ::close(eventFd); };
+  SCOPE_EXIT {
+    ::close(eventFd);
+  };
 
   // verify for useRegisteredFds = false we get a nullptr
   // IoUringFdRegistrationRecord
@@ -985,7 +989,9 @@ TEST(IoUringBackend, FileReadWrite) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDWR);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   auto* backendPtr = dynamic_cast<folly::IoUringBackend*>(evbPtr->getBackend());
   CHECK(!!backendPtr);
@@ -1051,7 +1057,9 @@ TEST(IoUringBackend, FileReadvWritev) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDWR);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   auto* backendPtr = dynamic_cast<folly::IoUringBackend*>(evbPtr->getBackend());
   CHECK(!!backendPtr);
@@ -1145,7 +1153,9 @@ TEST(IoUringBackend, FileReadMany) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDWR);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   auto* backendPtr = dynamic_cast<folly::IoUringBackend*>(evbPtr->getBackend());
   CHECK(!!backendPtr);
@@ -1205,7 +1215,9 @@ TEST(IoUringBackend, FileWriteMany) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDWR);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   auto* backendPtr = dynamic_cast<folly::IoUringBackend*>(evbPtr->getBackend());
   CHECK(!!backendPtr);
diff --git a/folly/experimental/io/test/IoUringTest.cpp b/folly/experimental/io/test/IoUringTest.cpp
index 7b378972b52..7967bf485c6 100644
--- a/folly/experimental/io/test/IoUringTest.cpp
+++ b/folly/experimental/io/test/IoUringTest.cpp
@@ -59,7 +59,9 @@ TEST(IoUringTest, RegisteredBuffers) {
   if (fd == -1)
     fd = ::open(tempFile.path().c_str(), O_RDWR);
   SKIP_IF(fd == -1) << "Tempfile can't be opened: " << folly::errnoStr(errno);
-  SCOPE_EXIT { ::close(fd); };
+  SCOPE_EXIT {
+    ::close(fd);
+  };
 
   folly::test::async_base_test_lib_detail::TestUtil::ManagedBuffer
       regFdWriteBuf =
diff --git a/folly/experimental/observer/detail/ObserverManager.h b/folly/experimental/observer/detail/ObserverManager.h
index 5f420751eb2..ade61ebf307 100644
--- a/folly/experimental/observer/detail/ObserverManager.h
+++ b/folly/experimental/observer/detail/ObserverManager.h
@@ -90,7 +90,9 @@ class ObserverManager {
 
     folly::fibers::runInMainContext([&] {
       auto inManagerThread = std::exchange(inManagerThread_, true);
-      SCOPE_EXIT { inManagerThread_ = inManagerThread; };
+      SCOPE_EXIT {
+        inManagerThread_ = inManagerThread;
+      };
 
       std::shared_lock rh(instance.versionMutex_);
 
@@ -140,7 +142,9 @@ class ObserverManager {
     template <typename F>
     static invoke_result_t<F> withDependencyRecordingDisabled(F f) {
       auto* const dependencies = std::exchange(currentDependencies_, nullptr);
-      SCOPE_EXIT { currentDependencies_ = dependencies; };
+      SCOPE_EXIT {
+        currentDependencies_ = dependencies;
+      };
 
       return f();
     }
diff --git a/folly/experimental/settings/Settings.h b/folly/experimental/settings/Settings.h
index 4a0c3e293fb..d40c6340722 100644
--- a/folly/experimental/settings/Settings.h
+++ b/folly/experimental/settings/Settings.h
@@ -194,13 +194,14 @@ class SettingWrapper {
   /* Fastpath optimization, see notes in FOLLY_SETTINGS_DEFINE_LOCAL_FUNC__.   \
      Aggregate all off these together in a single section for better TLB       \
      and cache locality. */                                                    \
-  __attribute__((__section__(".folly.settings.cache")))::std::atomic<          \
+  __attribute__((__section__(".folly.settings.cache"))) ::std::atomic<         \
       ::folly::settings::detail::SettingCore<_Type>*>                          \
       FOLLY_SETTINGS_CACHE__##_project##_##_name;                              \
   /* Location for the small value cache (if _Type is small and trivial).       \
      Intentionally located right after the pointer cache above to take         \
      advantage of the prefetching */                                           \
-  __attribute__((__section__(".folly.settings.cache")))::std::atomic<uint64_t> \
+  __attribute__((                                                              \
+      __section__(".folly.settings.cache"))) ::std::atomic<uint64_t>           \
       FOLLY_SETTINGS_TRIVIAL__##_project##_##_name;                            \
   /* Meyers singleton to avoid SIOF */                                         \
   FOLLY_NOINLINE ::folly::settings::detail::SettingCore<_Type>&                \
diff --git a/folly/experimental/symbolizer/ElfCache.cpp b/folly/experimental/symbolizer/ElfCache.cpp
index 168ee8c2442..06fd9cc1892 100644
--- a/folly/experimental/symbolizer/ElfCache.cpp
+++ b/folly/experimental/symbolizer/ElfCache.cpp
@@ -52,7 +52,9 @@ std::shared_ptr<ElfFile> SignalSafeElfCache::getFile(StringPiece p) {
   sigset_t oldsigs;
   sigemptyset(&oldsigs);
   sigprocmask(SIG_SETMASK, &newsigs, &oldsigs);
-  SCOPE_EXIT { sigprocmask(SIG_SETMASK, &oldsigs, nullptr); };
+  SCOPE_EXIT {
+    sigprocmask(SIG_SETMASK, &oldsigs, nullptr);
+  };
 
   if (!state_) {
     state_.emplace();
diff --git a/folly/experimental/symbolizer/SignalHandler.cpp b/folly/experimental/symbolizer/SignalHandler.cpp
index f28ad0904cf..28d1c634bad 100644
--- a/folly/experimental/symbolizer/SignalHandler.cpp
+++ b/folly/experimental/symbolizer/SignalHandler.cpp
@@ -186,7 +186,9 @@ void printHex(uint64_t val) {
 }
 
 void dumpTimeInfo() {
-  SCOPE_EXIT { flush(); };
+  SCOPE_EXIT {
+    flush();
+  };
   time_t now = time(nullptr);
   print("*** Aborted at ");
   printDec(now);
@@ -348,7 +350,9 @@ const char* signal_reason(int signum, int si_code) {
 }
 
 void dumpSignalInfo(int signum, siginfo_t* siginfo) {
-  SCOPE_EXIT { flush(); };
+  SCOPE_EXIT {
+    flush();
+  };
   // Get the signal name, if possible.
   const char* name = nullptr;
   for (auto p = kFatalSignals; p->name; ++p) {
diff --git a/folly/experimental/symbolizer/SymbolizePrinter.cpp b/folly/experimental/symbolizer/SymbolizePrinter.cpp
index deba0d18215..692bffc3743 100644
--- a/folly/experimental/symbolizer/SymbolizePrinter.cpp
+++ b/folly/experimental/symbolizer/SymbolizePrinter.cpp
@@ -67,7 +67,9 @@ void SymbolizePrinter::print(const SymbolizedFrame& frame) {
     return;
   }
 
-  SCOPE_EXIT { color(Color::Default); };
+  SCOPE_EXIT {
+    color(Color::Default);
+  };
 
   if (!(options_ & NO_FRAME_ADDRESS) && !(options_ & TERSE_FILE_AND_LINE)) {
     color(kAddressColor);
diff --git a/folly/experimental/symbolizer/Symbolizer.cpp b/folly/experimental/symbolizer/Symbolizer.cpp
index cf92bec47f5..71c9c838d33 100644
--- a/folly/experimental/symbolizer/Symbolizer.cpp
+++ b/folly/experimental/symbolizer/Symbolizer.cpp
@@ -300,7 +300,9 @@ FastStackTracePrinter::FastStackTracePrinter(
 FastStackTracePrinter::~FastStackTracePrinter() = default;
 
 void FastStackTracePrinter::printStackTrace(bool symbolize) {
-  SCOPE_EXIT { printer_->flush(); };
+  SCOPE_EXIT {
+    printer_->flush();
+  };
 
   FrameArray<kMaxStackTraceDepth> addresses;
   auto printStack = [this, &addresses, &symbolize] {
@@ -399,7 +401,9 @@ void SafeStackTracePrinter::printUnsymbolizedStackTrace() {
 }
 
 void SafeStackTracePrinter::printStackTrace(bool symbolize) {
-  SCOPE_EXIT { flush(); };
+  SCOPE_EXIT {
+    flush();
+  };
 
   // Skip the getStackTrace frame
   if (!getStackTraceSafe(*addresses_)) {
@@ -550,8 +554,8 @@ void UnsafeSelfAllocateStackTracePrinter::printSymbolizedStackTrace() {
 
   makecontext(
       &alt,
-      (void (*)())(void (*)(
-          UnsafeSelfAllocateStackTracePrinter*))(contextStart),
+      (void (*)())(void (*)(UnsafeSelfAllocateStackTracePrinter*))(
+          contextStart),
       /* argc */ 1,
       /* arg */ this);
   void* currentFakestack;
diff --git a/folly/experimental/test/AutoTimerTest.cpp b/folly/experimental/test/AutoTimerTest.cpp
index dfc9e263df3..d653c0539c1 100644
--- a/folly/experimental/test/AutoTimerTest.cpp
+++ b/folly/experimental/test/AutoTimerTest.cpp
@@ -120,7 +120,9 @@ TEST(TestAutoTimer, MovedObjectDestructionDoesntLog) {
   const std::vector<std::string> expectedMsgs = {
       "BEFORE_MOVE", "AFTER_MOVE", "END"};
   int32_t current = 0;
-  SCOPE_EXIT { EXPECT_EQ(3, current); };
+  SCOPE_EXIT {
+    EXPECT_EQ(3, current);
+  };
 
   auto timer = [&expectedMsgs, &current] {
     auto oldTimer = folly::makeAutoTimer(
diff --git a/folly/experimental/test/NestedCommandLineAppExample.cpp b/folly/experimental/test/NestedCommandLineAppExample.cpp
index aa50726e8e2..4516259c4bc 100644
--- a/folly/experimental/test/NestedCommandLineAppExample.cpp
+++ b/folly/experimental/test/NestedCommandLineAppExample.cpp
@@ -66,7 +66,9 @@ class Concatenator {
 void Concatenator::cat(FILE* file) {
   char* lineBuf = nullptr;
   size_t lineBufSize = 0;
-  SCOPE_EXIT { free(lineBuf); };
+  SCOPE_EXIT {
+    free(lineBuf);
+  };
 
   ssize_t n;
   while ((n = getline(&lineBuf, &lineBufSize, file)) >= 0) {
diff --git a/folly/experimental/test/RelaxedConcurrentPriorityQueueTest.cpp b/folly/experimental/test/RelaxedConcurrentPriorityQueueTest.cpp
index 6c4b2d1fa15..5843b3de000 100644
--- a/folly/experimental/test/RelaxedConcurrentPriorityQueueTest.cpp
+++ b/folly/experimental/test/RelaxedConcurrentPriorityQueueTest.cpp
@@ -1162,8 +1162,7 @@ TEST(CPQ, Accuracy) {
   for (auto s : test_sizes) {
     for (auto p : rates) {
       std::cout << "\n------ Size: " << s << "  Get top: " << 100. / p << "%"
-                << " (Num: " << s / p << ")"
-                << " ------" << std::endl;
+                << " (Num: " << s / p << ")" << " ------" << std::endl;
       accuracy_test<Queue<int>>("FIFO Q", s, p);
       accuracy_test<RelaxedConcurrentPriorityQueue<int, false, false, 0>>(
           "RCPQ(strict)", s, p);
diff --git a/folly/experimental/test/SingleWriterFixedHashMapTest.cpp b/folly/experimental/test/SingleWriterFixedHashMapTest.cpp
index 34dfdab597a..dad41bae069 100644
--- a/folly/experimental/test/SingleWriterFixedHashMapTest.cpp
+++ b/folly/experimental/test/SingleWriterFixedHashMapTest.cpp
@@ -355,8 +355,7 @@ TEST(SingleWriterFixedHashMapBench, Bench) {
       << std::endl;
   for (int i : nthr) {
     std::cout << "============================== " << std::setw(2) << i
-              << " threads "
-              << "==============================" << std::endl;
+              << " threads " << "==============================" << std::endl;
     const uint64_t ops = FLAGS_ops;
     std::cout << "10x find                       ";
     bench_find(i, ops);
diff --git a/folly/fibers/Baton.h b/folly/fibers/Baton.h
index 326030c761c..b924627fa0b 100644
--- a/folly/fibers/Baton.h
+++ b/folly/fibers/Baton.h
@@ -289,7 +289,7 @@ class BatonAwaitableWaiter : public Baton::Waiter {
 } // namespace detail
 
 inline detail::BatonAwaitableWaiter /* implicit */ operator co_await(
-    Baton& baton) {
+    Baton & baton) {
   return detail::BatonAwaitableWaiter(baton);
 }
 #endif
diff --git a/folly/fibers/ExecutorLoopController-inl.h b/folly/fibers/ExecutorLoopController-inl.h
index 5108e94e316..e0bd5892bfc 100644
--- a/folly/fibers/ExecutorLoopController-inl.h
+++ b/folly/fibers/ExecutorLoopController-inl.h
@@ -53,7 +53,9 @@ inline void ExecutorLoopController::schedule() {
 inline void ExecutorLoopController::runLoop() {
   auto oldLoopThread = loopThread_.exchange(std::this_thread::get_id());
   DCHECK(oldLoopThread == std::thread::id{});
-  SCOPE_EXIT { loopThread_ = std::thread::id{}; };
+  SCOPE_EXIT {
+    loopThread_ = std::thread::id{};
+  };
 
   if (!executorKeepAlive_) {
     if (!fm_->hasTasks()) {
diff --git a/folly/fibers/FiberManagerInternal-inl.h b/folly/fibers/FiberManagerInternal-inl.h
index 95992edd8bf..c83c5221ccb 100644
--- a/folly/fibers/FiberManagerInternal-inl.h
+++ b/folly/fibers/FiberManagerInternal-inl.h
@@ -271,7 +271,9 @@ inline size_t FiberManager::recordStackPosition(size_t position) {
 
 inline void FiberManager::loopUntilNoReadyImpl() {
   runFibersHelper([&] {
-    SCOPE_EXIT { isLoopScheduled_ = false; };
+    SCOPE_EXIT {
+      isLoopScheduled_ = false;
+    };
 
     bool hadRemote = true;
     while (hadRemote) {
@@ -317,7 +319,9 @@ inline void FiberManager::runEagerFiber(Fiber* fiber) {
 inline void FiberManager::runEagerFiberImpl(Fiber* fiber) {
   folly::fibers::runInMainContext([&] {
     auto prevCurrentFiber = std::exchange(currentFiber_, fiber);
-    SCOPE_EXIT { currentFiber_ = prevCurrentFiber; };
+    SCOPE_EXIT {
+      currentFiber_ = prevCurrentFiber;
+    };
     runFibersHelper([&] { runReadyFiber(fiber); });
   });
 }
diff --git a/folly/functional/Invoke.h b/folly/functional/Invoke.h
index 4864a26d3cc..b5e5c764e76 100644
--- a/folly/functional/Invoke.h
+++ b/folly/functional/Invoke.h
@@ -33,8 +33,10 @@
 #include <folly/lang/CustomizationPoint.h>
 
 #define FOLLY_DETAIL_FORWARD_REF(a) static_cast<decltype(a)&&>(a)
-#define FOLLY_DETAIL_FORWARD_BODY(e) \
-  noexcept(noexcept(e))->decltype(e) { return e; }
+#define FOLLY_DETAIL_FORWARD_BODY(e)   \
+  noexcept(noexcept(e))->decltype(e) { \
+    return e;                          \
+  }
 
 /**
  *  include or backport:
@@ -134,7 +136,7 @@ template <typename F>
 struct traits {
   template <typename... A>
   using result = decltype( //
-      FOLLY_DECLVAL(F &&)(FOLLY_DECLVAL(A &&)...));
+      FOLLY_DECLVAL(F&&)(FOLLY_DECLVAL(A&&)...));
   template <typename... A>
   static constexpr bool nothrow = noexcept( //
       FOLLY_DECLVAL(F&&)(FOLLY_DECLVAL(A&&)...));
@@ -143,7 +145,7 @@ template <typename P>
 struct traits_member_ptr {
   template <typename... A>
   using result = decltype( //
-      std::mem_fn(FOLLY_DECLVAL(P))(FOLLY_DECLVAL(A &&)...));
+      std::mem_fn(FOLLY_DECLVAL(P))(FOLLY_DECLVAL(A&&)...));
   template <typename... A>
   static constexpr bool nothrow = noexcept( //
       std::mem_fn(FOLLY_DECLVAL(P))(FOLLY_DECLVAL(A&&)...));
@@ -759,10 +761,7 @@ using tag_invoke_result_t = decltype(tag_invoke(
 template <typename Tag, typename... Args>
 auto try_tag_invoke(int) noexcept(
     noexcept(tag_invoke(FOLLY_DECLVAL(Tag&&), FOLLY_DECLVAL(Args&&)...)))
-    -> decltype(
-        static_cast<void>(
-            tag_invoke(FOLLY_DECLVAL(Tag &&), FOLLY_DECLVAL(Args&&)...)),
-        std::true_type{});
+    -> decltype(static_cast<void>(tag_invoke(FOLLY_DECLVAL(Tag&&), FOLLY_DECLVAL(Args&&)...)), std::true_type{});
 
 template <typename Tag, typename... Args>
 std::false_type try_tag_invoke(...) noexcept(false);
diff --git a/folly/functional/Partial.h b/folly/functional/Partial.h
index 52b9ed7640b..900cc048e94 100644
--- a/folly/functional/Partial.h
+++ b/folly/functional/Partial.h
@@ -57,22 +57,30 @@ class Partial {
 
   template <typename... CArgs>
   auto operator()(CArgs&&... cargs) & -> decltype(invokeForward(
-      std::declval<Partial&>(), Indexes{}, std::declval<CArgs>()...)) {
+                                          std::declval<Partial&>(),
+                                          Indexes{},
+                                          std::declval<CArgs>()...)) {
     return invokeForward(*this, Indexes{}, std::forward<CArgs>(cargs)...);
   }
   template <typename... CArgs>
   auto operator()(CArgs&&... cargs) const& -> decltype(invokeForward(
-      std::declval<const Partial&>(), Indexes{}, std::declval<CArgs>()...)) {
+                                               std::declval<const Partial&>(),
+                                               Indexes{},
+                                               std::declval<CArgs>()...)) {
     return invokeForward(*this, Indexes{}, std::forward<CArgs>(cargs)...);
   }
   template <typename... As>
   auto operator()(As&&... a) && -> decltype(invokeForward(
-      std::declval<Partial&&>(), Indexes{}, std::declval<As>()...)) {
+                                    std::declval<Partial&&>(),
+                                    Indexes{},
+                                    std::declval<As>()...)) {
     return invokeForward(std::move(*this), Indexes{}, std::forward<As>(a)...);
   }
   template <typename... As>
   auto operator()(As&&... as) const&& -> decltype(invokeForward(
-      std::declval<const Partial&&>(), Indexes{}, std::declval<As>()...)) {
+                                          std::declval<const Partial&&>(),
+                                          Indexes{},
+                                          std::declval<As>()...)) {
     return invokeForward(std::move(*this), Indexes{}, std::forward<As>(as)...);
   }
 
@@ -111,8 +119,8 @@ class Partial {
  */
 template <typename F, typename... Args>
 auto partial(F&& f, Args&&... args) -> detail::partial::Partial< //
-    typename std::decay<F>::type,
-    typename std::decay<Args>::type...> {
+                                        typename std::decay<F>::type,
+                                        typename std::decay<Args>::type...> {
   return {
       detail::partial::PartialConstructFromCallable{},
       std::forward<F>(f),
diff --git a/folly/functional/protocol.h b/folly/functional/protocol.h
index 4e9e3e2bcd4..88b1ecf60d6 100644
--- a/folly/functional/protocol.h
+++ b/folly/functional/protocol.h
@@ -58,7 +58,7 @@ struct match_empty_function_protocol_fn {
 
   template <typename T>
   static constexpr bool cx_matches_v =
-      require_sizeof<T>&& is_detected_v<detect_from_eq_nullptr, T>;
+      require_sizeof<T> && is_detected_v<detect_from_eq_nullptr, T>;
 
  public:
   template <typename T, std::enable_if_t<!cx_matches_v<T>, int> = 0>
@@ -143,7 +143,7 @@ struct match_safely_invocable_as_protocol_impl_ {
   template <typename F, typename FCVR = fun_cvref<F>>
   static constexpr bool is_invocable_r_v = std::is_reference<FCVR>::value
       ? is_invocable_r_<F>::value
-      : is_invocable_r_<F&>::value&& is_invocable_r_<F&&>::value;
+      : is_invocable_r_<F&>::value && is_invocable_r_<F&&>::value;
 };
 
 template <
diff --git a/folly/functional/test/traits_test.cpp b/folly/functional/test/traits_test.cpp
index 829b986faeb..51eac92f959 100644
--- a/folly/functional/test/traits_test.cpp
+++ b/folly/functional/test/traits_test.cpp
@@ -96,26 +96,26 @@ TEST_F(TraitsTest, function_traits) {
   EXPECT_TRUE((is_result_type_v<vc, vc() const noexcept>));
   EXPECT_TRUE((is_result_type_v<vc, vc() volatile noexcept>));
   EXPECT_TRUE((is_result_type_v<vc, vc() const volatile noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc()& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc() const& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc() volatile& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc() const volatile& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc()&& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc() const&& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc() volatile&& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc() const volatile&& noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc() & noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc() const & noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc() volatile & noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc() const volatile & noexcept>));
+  EXPECT_TRUE((is_result_type_v < vc, vc() && noexcept >));
+  EXPECT_TRUE((is_result_type_v < vc, vc() const&& noexcept >));
+  EXPECT_TRUE((is_result_type_v < vc, vc() volatile && noexcept >));
+  EXPECT_TRUE((is_result_type_v < vc, vc() const volatile&& noexcept >));
   EXPECT_TRUE((is_result_type_v<vc, vc(...) noexcept>));
   EXPECT_TRUE((is_result_type_v<vc, vc(...) const noexcept>));
   EXPECT_TRUE((is_result_type_v<vc, vc(...) volatile noexcept>));
   EXPECT_TRUE((is_result_type_v<vc, vc(...) const volatile noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...)& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...) const& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...) volatile& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...) const volatile& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...)&& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...) const&& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...) volatile&& noexcept>));
-  EXPECT_TRUE((is_result_type_v<vc, vc(...) const volatile&& noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc(...) & noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc(...) const & noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc(...) volatile & noexcept>));
+  EXPECT_TRUE((is_result_type_v<vc, vc(...) const volatile & noexcept>));
+  EXPECT_TRUE((is_result_type_v < vc, vc(...) && noexcept >));
+  EXPECT_TRUE((is_result_type_v < vc, vc(...) const&& noexcept >));
+  EXPECT_TRUE((is_result_type_v < vc, vc(...) volatile && noexcept >));
+  EXPECT_TRUE((is_result_type_v < vc, vc(...) const volatile&& noexcept >));
 
   //  is_nothrow
 
@@ -147,26 +147,26 @@ TEST_F(TraitsTest, function_traits) {
   EXPECT_TRUE((is_nothrow_v<void() const noexcept>));
   EXPECT_TRUE((is_nothrow_v<void() volatile noexcept>));
   EXPECT_TRUE((is_nothrow_v<void() const volatile noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void()& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void() const& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void() volatile& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void() const volatile& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void()&& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void() const&& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void() volatile&& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void() const volatile&& noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void() & noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void() const & noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void() volatile & noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void() const volatile & noexcept>));
+  EXPECT_TRUE((is_nothrow_v < void() && noexcept >));
+  EXPECT_TRUE((is_nothrow_v < void() const&& noexcept >));
+  EXPECT_TRUE((is_nothrow_v < void() volatile && noexcept >));
+  EXPECT_TRUE((is_nothrow_v < void() const volatile&& noexcept >));
   EXPECT_TRUE((is_nothrow_v<void(...) noexcept>));
   EXPECT_TRUE((is_nothrow_v<void(...) const noexcept>));
   EXPECT_TRUE((is_nothrow_v<void(...) volatile noexcept>));
   EXPECT_TRUE((is_nothrow_v<void(...) const volatile noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...)& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...) const& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...) volatile& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...) const volatile& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...)&& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...) const&& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...) volatile&& noexcept>));
-  EXPECT_TRUE((is_nothrow_v<void(...) const volatile&& noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void(...) & noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void(...) const & noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void(...) volatile & noexcept>));
+  EXPECT_TRUE((is_nothrow_v<void(...) const volatile & noexcept>));
+  EXPECT_TRUE((is_nothrow_v < void(...) && noexcept >));
+  EXPECT_TRUE((is_nothrow_v < void(...) const&& noexcept >));
+  EXPECT_TRUE((is_nothrow_v < void(...) volatile && noexcept >));
+  EXPECT_TRUE((is_nothrow_v < void(...) const volatile&& noexcept >));
 
   //  variadic
 
@@ -198,26 +198,26 @@ TEST_F(TraitsTest, function_traits) {
   EXPECT_FALSE((is_variadic_v<void() const noexcept>));
   EXPECT_FALSE((is_variadic_v<void() volatile noexcept>));
   EXPECT_FALSE((is_variadic_v<void() const volatile noexcept>));
-  EXPECT_FALSE((is_variadic_v<void()& noexcept>));
-  EXPECT_FALSE((is_variadic_v<void() const& noexcept>));
-  EXPECT_FALSE((is_variadic_v<void() volatile& noexcept>));
-  EXPECT_FALSE((is_variadic_v<void() const volatile& noexcept>));
-  EXPECT_FALSE((is_variadic_v<void()&& noexcept>));
-  EXPECT_FALSE((is_variadic_v<void() const&& noexcept>));
-  EXPECT_FALSE((is_variadic_v<void() volatile&& noexcept>));
-  EXPECT_FALSE((is_variadic_v<void() const volatile&& noexcept>));
+  EXPECT_FALSE((is_variadic_v<void() & noexcept>));
+  EXPECT_FALSE((is_variadic_v<void() const & noexcept>));
+  EXPECT_FALSE((is_variadic_v<void() volatile & noexcept>));
+  EXPECT_FALSE((is_variadic_v<void() const volatile & noexcept>));
+  EXPECT_FALSE((is_variadic_v < void() && noexcept >));
+  EXPECT_FALSE((is_variadic_v < void() const&& noexcept >));
+  EXPECT_FALSE((is_variadic_v < void() volatile && noexcept >));
+  EXPECT_FALSE((is_variadic_v < void() const volatile&& noexcept >));
   EXPECT_TRUE((is_variadic_v<void(...) noexcept>));
   EXPECT_TRUE((is_variadic_v<void(...) const noexcept>));
   EXPECT_TRUE((is_variadic_v<void(...) volatile noexcept>));
   EXPECT_TRUE((is_variadic_v<void(...) const volatile noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...)& noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...) const& noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...) volatile& noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...) const volatile& noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...)&& noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...) const&& noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...) volatile&& noexcept>));
-  EXPECT_TRUE((is_variadic_v<void(...) const volatile&& noexcept>));
+  EXPECT_TRUE((is_variadic_v<void(...) & noexcept>));
+  EXPECT_TRUE((is_variadic_v<void(...) const & noexcept>));
+  EXPECT_TRUE((is_variadic_v<void(...) volatile & noexcept>));
+  EXPECT_TRUE((is_variadic_v<void(...) const volatile & noexcept>));
+  EXPECT_TRUE((is_variadic_v < void(...) && noexcept >));
+  EXPECT_TRUE((is_variadic_v < void(...) const&& noexcept >));
+  EXPECT_TRUE((is_variadic_v < void(...) volatile && noexcept >));
+  EXPECT_TRUE((is_variadic_v < void(...) const volatile&& noexcept >));
 
   //  argument
 
@@ -249,30 +249,36 @@ TEST_F(TraitsTest, function_traits) {
   EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) const noexcept>));
   EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) volatile noexcept>));
   EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) const volatile noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*)& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) const& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) volatile& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) const volatile& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*)&& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) const&& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) volatile&& noexcept>));
+  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) & noexcept>));
+  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) const & noexcept>));
+  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*) volatile & noexcept>));
+  EXPECT_TRUE(
+      (is_arg_type_v<vc*, 1, void(int, vc*) const volatile & noexcept>));
+  EXPECT_TRUE((is_arg_type_v < vc*, 1, void(int, vc*) && noexcept >));
+  EXPECT_TRUE((is_arg_type_v < vc*, 1, void(int, vc*) const&& noexcept >));
+  EXPECT_TRUE((is_arg_type_v < vc*, 1, void(int, vc*) volatile && noexcept >));
   EXPECT_TRUE(( //
-      is_arg_type_v<vc*, 1, void(int, vc*) const volatile&& noexcept>));
+      is_arg_type_v < vc*,
+      1,
+      void(int, vc*) const volatile&& noexcept >));
   EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) noexcept>));
   EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) const noexcept>));
   EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) volatile noexcept>));
   EXPECT_TRUE(( //
       is_arg_type_v<vc*, 1, void(int, vc*, ...) const volatile noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...)& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) const& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) volatile& noexcept>));
+  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) & noexcept>));
+  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) const & noexcept>));
+  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) volatile & noexcept>));
   EXPECT_TRUE(( //
-      is_arg_type_v<vc*, 1, void(int, vc*, ...) const volatile& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...)&& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) const&& noexcept>));
-  EXPECT_TRUE((is_arg_type_v<vc*, 1, void(int, vc*, ...) volatile&& noexcept>));
+      is_arg_type_v<vc*, 1, void(int, vc*, ...) const volatile & noexcept>));
+  EXPECT_TRUE((is_arg_type_v < vc*, 1, void(int, vc*, ...) && noexcept >));
+  EXPECT_TRUE((is_arg_type_v < vc*, 1, void(int, vc*, ...) const&& noexcept >));
+  EXPECT_TRUE(
+      (is_arg_type_v < vc*, 1, void(int, vc*, ...) volatile && noexcept >));
   EXPECT_TRUE(( //
-      is_arg_type_v<vc*, 1, void(int, vc*, ...) const volatile&& noexcept>));
+      is_arg_type_v < vc*,
+      1,
+      void(int, vc*, ...) const volatile&& noexcept >));
 
   //  arguments
 
@@ -304,29 +310,32 @@ TEST_F(TraitsTest, function_traits) {
   EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const noexcept>));
   EXPECT_EQ(3, (args_size_v<void(int, vc*, float) volatile noexcept>));
   EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const volatile noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float)& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) volatile& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const volatile& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float)&& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const&& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) volatile&& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const volatile&& noexcept>));
+  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) & noexcept>));
+  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const & noexcept>));
+  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) volatile & noexcept>));
+  EXPECT_EQ(3, (args_size_v<void(int, vc*, float) const volatile & noexcept>));
+  EXPECT_EQ(3, (args_size_v < void(int, vc*, float) && noexcept >));
+  EXPECT_EQ(3, (args_size_v < void(int, vc*, float) const&& noexcept >));
+  EXPECT_EQ(3, (args_size_v < void(int, vc*, float) volatile && noexcept >));
+  EXPECT_EQ(
+      3, (args_size_v < void(int, vc*, float) const volatile&& noexcept >));
   EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) noexcept>));
   EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) const noexcept>));
   EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) volatile noexcept>));
   EXPECT_EQ(
       3, (args_size_v<void(int, vc*, float, ...) const volatile noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...)& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) const& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) volatile& noexcept>));
+  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) & noexcept>));
+  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) const & noexcept>));
+  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) volatile & noexcept>));
+  EXPECT_EQ(
+      3, (args_size_v<void(int, vc*, float, ...) const volatile & noexcept>));
+  EXPECT_EQ(3, (args_size_v < void(int, vc*, float, ...) && noexcept >));
+  EXPECT_EQ(3, (args_size_v < void(int, vc*, float, ...) const&& noexcept >));
   EXPECT_EQ(
-      3, (args_size_v<void(int, vc*, float, ...) const volatile& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...)&& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) const&& noexcept>));
-  EXPECT_EQ(3, (args_size_v<void(int, vc*, float, ...) volatile&& noexcept>));
+      3, (args_size_v < void(int, vc*, float, ...) volatile && noexcept >));
   EXPECT_EQ(
-      3, (args_size_v<void(int, vc*, float, ...) const volatile&& noexcept>));
+      3,
+      (args_size_v < void(int, vc*, float, ...) const volatile&& noexcept >));
 
   //  value_like
 
@@ -361,37 +370,39 @@ TEST_F(TraitsTest, function_traits) {
   EXPECT_TRUE((is_cvref_t<int volatile, int, void() volatile noexcept>));
   EXPECT_TRUE(( //
       is_cvref_t<int const volatile, int, void() const volatile noexcept>));
-  EXPECT_TRUE((is_cvref_t<int&, int, void()& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int const&, int, void() const& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int volatile&, int, void() volatile& noexcept>));
+  EXPECT_TRUE((is_cvref_t<int&, int, void() & noexcept>));
+  EXPECT_TRUE((is_cvref_t<int const&, int, void() const & noexcept>));
+  EXPECT_TRUE((is_cvref_t<int volatile&, int, void() volatile & noexcept>));
   EXPECT_TRUE(( //
-      is_cvref_t<int const volatile&, int, void() const volatile& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int&&, int, void()&& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int const&&, int, void() const&& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int volatile&&, int, void() volatile&& noexcept>));
-  EXPECT_TRUE((
-      is_cvref_t<int const volatile&&, int, void() const volatile&& noexcept>));
+      is_cvref_t<int const volatile&, int, void() const volatile & noexcept>));
+  EXPECT_TRUE((is_cvref_t < int&&, int, void()&& noexcept >));
+  EXPECT_TRUE((is_cvref_t < int const&&, int, void() const&& noexcept >));
+  EXPECT_TRUE((is_cvref_t < int volatile&&, int, void() volatile&& noexcept >));
+  EXPECT_TRUE(
+      (is_cvref_t < int const volatile&&,
+       int,
+       void() const volatile&& noexcept >));
   EXPECT_TRUE((is_cvref_t<int, int, void(...) noexcept>));
   EXPECT_TRUE((is_cvref_t<int const, int, void(...) const noexcept>));
   EXPECT_TRUE((is_cvref_t<int volatile, int, void(...) volatile noexcept>));
   EXPECT_TRUE(( //
       is_cvref_t<int const volatile, int, void(...) const volatile noexcept>));
-  EXPECT_TRUE((is_cvref_t<int&, int, void(...)& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int const&, int, void(...) const& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int volatile&, int, void(...) volatile& noexcept>));
+  EXPECT_TRUE((is_cvref_t<int&, int, void(...) & noexcept>));
+  EXPECT_TRUE((is_cvref_t<int const&, int, void(...) const & noexcept>));
+  EXPECT_TRUE((is_cvref_t<int volatile&, int, void(...) volatile & noexcept>));
   EXPECT_TRUE(( //
       is_cvref_t<
           int const volatile&,
           int,
-          void(...) const volatile& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int&&, int, void(...)&& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int const&&, int, void(...) const&& noexcept>));
-  EXPECT_TRUE((is_cvref_t<int volatile&&, int, void(...) volatile&& noexcept>));
+          void(...) const volatile & noexcept>));
+  EXPECT_TRUE((is_cvref_t < int&&, int, void(...)&& noexcept >));
+  EXPECT_TRUE((is_cvref_t < int const&&, int, void(...) const&& noexcept >));
+  EXPECT_TRUE(
+      (is_cvref_t < int volatile&&, int, void(...) volatile&& noexcept >));
   EXPECT_TRUE(( //
-      is_cvref_t<
-          int const volatile&&,
-          int,
-          void(...) const volatile&& noexcept>));
+      is_cvref_t < int const volatile&&,
+      int,
+      void(...) const volatile&& noexcept >));
 }
 
 TEST_F(TraitsTest, function_remove_cvref) {
@@ -428,14 +439,14 @@ TEST_F(TraitsTest, function_remove_cvref) {
   EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const noexcept>>));
   EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) volatile noexcept>>));
   EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const volatile noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*)& noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const& noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) volatile& noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const volatile& noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*)&& noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const&& noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) volatile&& noexcept>>));
-  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const volatile&& noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) & noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const & noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) volatile & noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const volatile & noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) && noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const && noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) volatile && noexcept>>));
+  EXPECT_TRUE((same_v<g, rem_cvref_t<char(int*) const volatile && noexcept>>));
 
   using gv = char(int*, ...) noexcept;
   EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) noexcept>>));
@@ -443,16 +454,16 @@ TEST_F(TraitsTest, function_remove_cvref) {
   EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) volatile noexcept>>));
   EXPECT_TRUE(( //
       same_v<gv, rem_cvref_t<char(int*, ...) const volatile noexcept>>));
-  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...)& noexcept>>));
-  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) const& noexcept>>));
-  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) volatile& noexcept>>));
+  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) & noexcept>>));
+  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) const & noexcept>>));
+  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) volatile & noexcept>>));
   EXPECT_TRUE(( //
-      same_v<gv, rem_cvref_t<char(int*, ...) const volatile& noexcept>>));
-  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...)&& noexcept>>));
-  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) const&& noexcept>>));
-  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) volatile&& noexcept>>));
+      same_v<gv, rem_cvref_t<char(int*, ...) const volatile & noexcept>>));
+  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) && noexcept>>));
+  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) const && noexcept>>));
+  EXPECT_TRUE((same_v<gv, rem_cvref_t<char(int*, ...) volatile && noexcept>>));
   EXPECT_TRUE(( //
-      same_v<gv, rem_cvref_t<char(int*, ...) const volatile&& noexcept>>));
+      same_v<gv, rem_cvref_t<char(int*, ...) const volatile && noexcept>>));
 }
 
 TEST_F(TraitsTest, function_like_value) {
@@ -494,19 +505,19 @@ TEST_F(TraitsTest, function_like_value) {
   EXPECT_TRUE((is_like_v<char(int*) volatile noexcept, int volatile, g>));
   EXPECT_TRUE(( //
       is_like_v<char(int*) const volatile noexcept, int const volatile, g>));
-  EXPECT_TRUE((is_like_v<char(int*)& noexcept, int&, g>));
-  EXPECT_TRUE((is_like_v<char(int*) const& noexcept, int const&, g>));
-  EXPECT_TRUE((is_like_v<char(int*) volatile& noexcept, int volatile&, g>));
+  EXPECT_TRUE((is_like_v<char(int*) & noexcept, int&, g>));
+  EXPECT_TRUE((is_like_v<char(int*) const & noexcept, int const&, g>));
+  EXPECT_TRUE((is_like_v<char(int*) volatile & noexcept, int volatile&, g>));
   EXPECT_TRUE(( //
-      is_like_v<char(int*) const volatile& noexcept, int const volatile&, g>));
-  EXPECT_TRUE((is_like_v<char(int*)&& noexcept, int&&, g>));
-  EXPECT_TRUE((is_like_v<char(int*) const&& noexcept, int const&&, g>));
-  EXPECT_TRUE((is_like_v<char(int*) volatile&& noexcept, int volatile&&, g>));
+      is_like_v<char(int*) const volatile & noexcept, int const volatile&, g>));
+  EXPECT_TRUE((is_like_v < char(int*) && noexcept, int&&, g >));
+  EXPECT_TRUE((is_like_v < char(int*) const&& noexcept, int const&&, g >));
+  EXPECT_TRUE(
+      (is_like_v < char(int*) volatile && noexcept, int volatile&&, g >));
   EXPECT_TRUE(( //
-      is_like_v<
-          char(int*) const volatile&& noexcept,
-          int const volatile&&,
-          g>));
+      is_like_v < char(int*) const volatile&& noexcept,
+      int const volatile&&,
+      g >));
 
   using gv = char(int*, ...) noexcept;
   EXPECT_TRUE((is_like_v<char(int*, ...) noexcept, int, gv>));
@@ -517,22 +528,24 @@ TEST_F(TraitsTest, function_like_value) {
           char(int*, ...) const volatile noexcept,
           int const volatile,
           gv>));
-  EXPECT_TRUE((is_like_v<char(int*, ...)& noexcept, int&, gv>));
-  EXPECT_TRUE((is_like_v<char(int*, ...) const& noexcept, int const&, gv>));
+  EXPECT_TRUE((is_like_v<char(int*, ...) & noexcept, int&, gv>));
+  EXPECT_TRUE((is_like_v<char(int*, ...) const & noexcept, int const&, gv>));
   EXPECT_TRUE(( //
-      is_like_v<char(int*, ...) volatile& noexcept, int volatile&, gv>));
+      is_like_v<char(int*, ...) volatile & noexcept, int volatile&, gv>));
   EXPECT_TRUE(( //
       is_like_v<
-          char(int*, ...) const volatile& noexcept,
+          char(int*, ...) const volatile & noexcept,
           int const volatile&,
           gv>));
-  EXPECT_TRUE((is_like_v<char(int*, ...)&& noexcept, int&&, gv>));
-  EXPECT_TRUE((is_like_v<char(int*, ...) const&& noexcept, int const&&, gv>));
+  EXPECT_TRUE((is_like_v < char(int*, ...) && noexcept, int&&, gv >));
+  EXPECT_TRUE(
+      (is_like_v < char(int*, ...) const&& noexcept, int const&&, gv >));
   EXPECT_TRUE(( //
-      is_like_v<char(int*, ...) volatile&& noexcept, int volatile&&, gv>));
+      is_like_v < char(int*, ...) volatile && noexcept,
+      int volatile&&,
+      gv >));
   EXPECT_TRUE(( //
-      is_like_v<
-          char(int*, ...) const volatile&& noexcept,
-          int const volatile&&,
-          gv>));
+      is_like_v < char(int*, ...) const volatile&& noexcept,
+      int const volatile&&,
+      gv >));
 }
diff --git a/folly/functional/traits.h b/folly/functional/traits.h
index 17765b28858..0b568133958 100644
--- a/folly/functional/traits.h
+++ b/folly/functional/traits.h
@@ -308,56 +308,56 @@ struct function_traits<R(A...) const volatile noexcept>
       detail::function_traits_cvref_<int const volatile> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...)& noexcept>
+struct function_traits<R(A...) & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
       detail::function_traits_cvref_<int&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...) const& noexcept>
+struct function_traits<R(A...) const & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
       detail::function_traits_cvref_<int const&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...) volatile& noexcept>
+struct function_traits<R(A...) volatile & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
       detail::function_traits_cvref_<int volatile&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...) const volatile& noexcept>
+struct function_traits<R(A...) const volatile & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
       detail::function_traits_cvref_<int const volatile&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...)&& noexcept>
+struct function_traits<R(A...) && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
       detail::function_traits_cvref_<int&&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...) const&& noexcept>
+struct function_traits<R(A...) const && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
       detail::function_traits_cvref_<int const&&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...) volatile&& noexcept>
+struct function_traits<R(A...) volatile && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
       detail::function_traits_cvref_<int volatile&&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A...) const volatile&& noexcept>
+struct function_traits<R(A...) const volatile && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<false>,
@@ -392,56 +392,56 @@ struct function_traits<R(A..., ...) const volatile noexcept>
       detail::function_traits_cvref_<int const volatile> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...)& noexcept>
+struct function_traits<R(A..., ...) & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
       detail::function_traits_cvref_<int&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...) const& noexcept>
+struct function_traits<R(A..., ...) const & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
       detail::function_traits_cvref_<int const&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...) volatile& noexcept>
+struct function_traits<R(A..., ...) volatile & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
       detail::function_traits_cvref_<int volatile&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...) const volatile& noexcept>
+struct function_traits<R(A..., ...) const volatile & noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
       detail::function_traits_cvref_<int const volatile&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...)&& noexcept>
+struct function_traits<R(A..., ...) && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
       detail::function_traits_cvref_<int&&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...) const&& noexcept>
+struct function_traits<R(A..., ...) const && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
       detail::function_traits_cvref_<int const&&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...) volatile&& noexcept>
+struct function_traits<R(A..., ...) volatile && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
       detail::function_traits_cvref_<int volatile&&> {};
 
 template <typename R, typename... A>
-struct function_traits<R(A..., ...) const volatile&& noexcept>
+struct function_traits<R(A..., ...) const volatile && noexcept>
     : detail::function_traits_base_<R(A...)>,
       detail::function_traits_nx_<true>,
       detail::function_traits_var_<true>,
diff --git a/folly/futures/Future.h b/folly/futures/Future.h
index 455398b97ec..538d232c1c3 100644
--- a/folly/futures/Future.h
+++ b/folly/futures/Future.h
@@ -1124,7 +1124,7 @@ class Future : private futures::detail::FutureBase<T> {
           int>::type = 0>
   Future& operator=(Future<T2>&& other) {
     return operator=(
-        std::move(other).thenValue([](T2&& v) { return T(std::move(v)); }));
+        std::move(other).thenValue([](T2 && v) { return T(std::move(v)); }));
   }
 
   using Base::cancel;
@@ -2525,8 +2525,12 @@ Future<T> reduce(It first, It last, T&& initial, F&& func);
 
 /// Sugar for the most common case
 template <class Collection, class T, class F>
-auto reduce(Collection&& c, T&& initial, F&& func) -> decltype(folly::reduce(
-    c.begin(), c.end(), static_cast<T&&>(initial), static_cast<F&&>(func))) {
+auto reduce(Collection&& c, T&& initial, F&& func)
+    -> decltype(folly::reduce(
+        c.begin(),
+        c.end(),
+        static_cast<T&&>(initial),
+        static_cast<F&&>(func))) {
   return folly::reduce(
       c.begin(), c.end(), static_cast<T&&>(initial), static_cast<F&&>(func));
 }
diff --git a/folly/futures/test/RetryingTest.cpp b/folly/futures/test/RetryingTest.cpp
index ffb2cebe0c7..87b695e08ca 100644
--- a/folly/futures/test/RetryingTest.cpp
+++ b/folly/futures/test/RetryingTest.cpp
@@ -336,7 +336,9 @@ TEST(RetryingTest, largeRetries) {
   newMemLimit.rlim_max = oldMemLimit.rlim_max;
   auto const lowered = // sanitizers reserve outside of the rlimit
       !folly::kIsSanitize && setrlimit(RLIMIT_AS, &newMemLimit) != 0;
-  SCOPE_EXIT { PCHECK(!lowered || setrlimit(RLIMIT_AS, &oldMemLimit) == 0); };
+  SCOPE_EXIT {
+    PCHECK(!lowered || setrlimit(RLIMIT_AS, &oldMemLimit) == 0);
+  };
 #endif
 
   TestExecutor executor(4);
diff --git a/folly/futures/test/WindowTest.cpp b/folly/futures/test/WindowTest.cpp
index 6405f75a1cb..6677fa27fc7 100644
--- a/folly/futures/test/WindowTest.cpp
+++ b/folly/futures/test/WindowTest.cpp
@@ -201,8 +201,7 @@ TEST(Window, parallel) {
   for (size_t i = 0; i < ps.size(); i++) {
     input.emplace_back(i);
   }
-  auto f = collect(window(
-      input, [&](int i) { return ps[i].getFuture(); }, 3));
+  auto f = collect(window(input, [&](int i) { return ps[i].getFuture(); }, 3));
 
   std::vector<std::thread> ts;
   boost::barrier barrier(ps.size() + 1);
@@ -231,8 +230,7 @@ TEST(Window, parallelWithError) {
   for (size_t i = 0; i < ps.size(); i++) {
     input.emplace_back(i);
   }
-  auto f = collect(window(
-      input, [&](int i) { return ps[i].getFuture(); }, 3));
+  auto f = collect(window(input, [&](int i) { return ps[i].getFuture(); }, 3));
 
   std::vector<std::thread> ts;
   boost::barrier barrier(ps.size() + 1);
@@ -263,8 +261,8 @@ TEST(Window, allParallelWithError) {
   for (size_t i = 0; i < ps.size(); i++) {
     input.emplace_back(i);
   }
-  auto f = collectAll(window(
-      input, [&](int i) { return ps[i].getFuture(); }, 3));
+  auto f =
+      collectAll(window(input, [&](int i) { return ps[i].getFuture(); }, 3));
 
   std::vector<std::thread> ts;
   boost::barrier barrier(ps.size() + 1);
@@ -364,8 +362,8 @@ TEST(WindowExecutor, parallel) {
   for (size_t i = 0; i < ps.size(); i++) {
     input.emplace_back(i);
   }
-  auto f = collect(window(
-      &executor, input, [&](int i) { return ps[i].getFuture(); }, 3));
+  auto f = collect(
+      window(&executor, input, [&](int i) { return ps[i].getFuture(); }, 3));
 
   std::vector<std::thread> ts;
   boost::barrier barrier(ps.size() + 1);
@@ -397,8 +395,8 @@ TEST(WindowExecutor, parallelWithError) {
   for (size_t i = 0; i < ps.size(); i++) {
     input.emplace_back(i);
   }
-  auto f = collect(window(
-      &executor, input, [&](int i) { return ps[i].getFuture(); }, 3));
+  auto f = collect(
+      window(&executor, input, [&](int i) { return ps[i].getFuture(); }, 3));
 
   std::vector<std::thread> ts;
   boost::barrier barrier(ps.size() + 1);
@@ -432,8 +430,8 @@ TEST(WindowExecutor, allParallelWithError) {
   for (size_t i = 0; i < ps.size(); i++) {
     input.emplace_back(i);
   }
-  auto f = collectAll(window(
-      &executor, input, [&](int i) { return ps[i].getFuture(); }, 3));
+  auto f = collectAll(
+      window(&executor, input, [&](int i) { return ps[i].getFuture(); }, 3));
 
   std::vector<std::thread> ts;
   boost::barrier barrier(ps.size() + 1);
diff --git a/folly/gen/Combine-inl.h b/folly/gen/Combine-inl.h
index f72e238d865..7bd25ef7a1f 100644
--- a/folly/gen/Combine-inl.h
+++ b/folly/gen/Combine-inl.h
@@ -165,7 +165,8 @@ auto add_to_tuple(Type1&& t1, std::tuple<Types2...> t2)
 
 template <class Type1, class Type2>
 auto add_to_tuple(Type1&& t1, Type2&& t2) -> decltype(std::make_tuple(
-    std::forward<Type1>(t1), std::forward<Type2>(t2))) {
+                                              std::forward<Type1>(t1),
+                                              std::forward<Type2>(t2))) {
   return std::make_tuple(std::forward<Type1>(t1), std::forward<Type2>(t2));
 }
 
@@ -173,9 +174,10 @@ auto add_to_tuple(Type1&& t1, Type2&& t2) -> decltype(std::make_tuple(
 class MergeTuples {
  public:
   template <class Tuple>
-  auto operator()(Tuple&& value) const -> decltype(add_to_tuple(
-      std::get<0>(std::forward<Tuple>(value)),
-      std::get<1>(std::forward<Tuple>(value)))) {
+  auto operator()(Tuple&& value) const
+      -> decltype(add_to_tuple(
+          std::get<0>(std::forward<Tuple>(value)),
+          std::get<1>(std::forward<Tuple>(value)))) {
     static_assert(
         std::tuple_size<typename std::remove_reference<Tuple>::type>::value ==
             2,
diff --git a/folly/gen/test/StringBenchmark.cpp b/folly/gen/test/StringBenchmark.cpp
index 010364411da..115203238e2 100644
--- a/folly/gen/test/StringBenchmark.cpp
+++ b/folly/gen/test/StringBenchmark.cpp
@@ -192,7 +192,9 @@ BENCHMARK_DRAW_LINE();
 void StringUnsplit_Gen(size_t iters, size_t joinSize) {
   std::vector<fbstring> v;
   BENCHMARK_SUSPEND {
-    FOR_EACH_RANGE (i, 0, joinSize) { v.push_back(to<fbstring>(rand())); }
+    FOR_EACH_RANGE (i, 0, joinSize) {
+      v.push_back(to<fbstring>(rand()));
+    }
   }
   size_t s = 0;
   fbstring buffer;
diff --git a/folly/hash/test/ChecksumBenchmark.cpp b/folly/hash/test/ChecksumBenchmark.cpp
index 2d0eaf29f7f..bdbfcf3cd83 100644
--- a/folly/hash/test/ChecksumBenchmark.cpp
+++ b/folly/hash/test/ChecksumBenchmark.cpp
@@ -23,8 +23,10 @@
 constexpr size_t kBufSize = 512 * 1024;
 uint8_t* buf;
 
-#define BENCH_CRC32(S) \
-  BENCHMARK(crc32_##S) { folly::doNotOptimizeAway(folly::crc32(buf, (S), 2)); }
+#define BENCH_CRC32(S)                                   \
+  BENCHMARK(crc32_##S) {                                 \
+    folly::doNotOptimizeAway(folly::crc32(buf, (S), 2)); \
+  }
 
 #define BENCH_CRC32C(S)                                   \
   BENCHMARK(crc32c_##S) {                                 \
diff --git a/folly/io/Cursor.cpp b/folly/io/Cursor.cpp
index 4b1547c2e67..530be5734ba 100644
--- a/folly/io/Cursor.cpp
+++ b/folly/io/Cursor.cpp
@@ -38,7 +38,9 @@ void Appender::vprintf(const char* fmt, va_list ap) {
   // passed the used arguments.  We'll only use apCopy if we need to retry.
   va_list apCopy;
   va_copy(apCopy, ap);
-  SCOPE_EXIT { va_end(apCopy); };
+  SCOPE_EXIT {
+    va_end(apCopy);
+  };
 
   // First try writing into our available data space.
   int ret =
diff --git a/folly/io/async/AsyncSSLSocket.cpp b/folly/io/async/AsyncSSLSocket.cpp
index 10ab34a3086..5a39dccd86f 100644
--- a/folly/io/async/AsyncSSLSocket.cpp
+++ b/folly/io/async/AsyncSSLSocket.cpp
@@ -523,8 +523,7 @@ void AsyncSSLSocket::invalidState(HandshakeCB* callback) {
   LOG(ERROR) << "AsyncSSLSocket(this=" << this << ", fd=" << fd_
              << ", state=" << int(state_) << ", sslState=" << sslState_ << ", "
              << "events=" << eventFlags_ << ", server=" << short(server_)
-             << "): "
-             << "sslAccept/Connect() called in invalid "
+             << "): " << "sslAccept/Connect() called in invalid "
              << "state, handshake callback " << handshakeCallback_
              << ", new callback " << callback;
   assert(!handshakeTimeout_.isScheduled());
@@ -1115,8 +1114,8 @@ bool AsyncSSLSocket::willBlock(
   }
   if (error == SSL_ERROR_WANT_WRITE) {
     VLOG(3) << "AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
-            << ", sslState=" << sslState_ << ", events=" << eventFlags_ << "): "
-            << "SSL_ERROR_WANT_WRITE";
+            << ", sslState=" << sslState_ << ", events=" << eventFlags_
+            << "): " << "SSL_ERROR_WANT_WRITE";
     // Register for write event if not already.
     updateEventRegistration(EventHandler::WRITE, EventHandler::READ);
     return true;
@@ -1178,17 +1177,13 @@ bool AsyncSSLSocket::willBlock(
     // Clear the rest.
     unsigned long lastError = *errErrorOut = ERR_get_error();
     ERR_clear_error();
-    VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", "
-            << "state=" << state_ << ", "
-            << "sslState=" << sslState_ << ", "
-            << "events=" << std::hex << eventFlags_ << "): "
-            << "SSL error: " << error << ", "
-            << "errno: " << errno << ", "
-            << "ret: " << ret << ", "
+    VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", " << "state=" << state_ << ", "
+            << "sslState=" << sslState_ << ", " << "events=" << std::hex
+            << eventFlags_ << "): " << "SSL error: " << error << ", "
+            << "errno: " << errno << ", " << "ret: " << ret << ", "
             << "read: " << BIO_number_read(SSL_get_rbio(ssl_.get())) << ", "
             << "written: " << BIO_number_written(SSL_get_wbio(ssl_.get()))
-            << ", "
-            << "func: " << ERR_func_error_string(lastError) << ", "
+            << ", " << "func: " << ERR_func_error_string(lastError) << ", "
             << "reason: " << ERR_reason_error_string(lastError);
     return false;
   }
@@ -1231,8 +1226,8 @@ void AsyncSSLSocket::restartSSLAccept() {
 
 void AsyncSSLSocket::handleAccept() noexcept {
   VLOG(3) << "AsyncSSLSocket::handleAccept() this=" << this << ", fd=" << fd_
-          << ", state=" << int(state_) << ", "
-          << "sslState=" << sslState_ << ", events=" << eventFlags_;
+          << ", state=" << int(state_) << ", " << "sslState=" << sslState_
+          << ", events=" << eventFlags_;
   assert(server_);
   assert(state_ == StateEnum::ESTABLISHED && sslState_ == STATE_ACCEPTING);
   if (!ssl_) {
@@ -1354,8 +1349,8 @@ void AsyncSSLSocket::handleReturnFromSSLAccept(int ret) {
 
 void AsyncSSLSocket::handleConnect() noexcept {
   VLOG(3) << "AsyncSSLSocket::handleConnect() this=" << this << ", fd=" << fd_
-          << ", state=" << int(state_) << ", "
-          << "sslState=" << sslState_ << ", events=" << eventFlags_;
+          << ", state=" << int(state_) << ", " << "sslState=" << sslState_
+          << ", events=" << eventFlags_;
   assert(!server_);
   if (state_ < StateEnum::ESTABLISHED) {
     return AsyncSocket::handleConnect();
@@ -1401,10 +1396,9 @@ void AsyncSSLSocket::handleConnect() noexcept {
   // STATE_CONNECTING.
   sslState_ = STATE_ESTABLISHED;
 
-  VLOG(3) << "AsyncSSLSocket " << this << ": "
-          << "fd " << fd_ << " successfully connected; "
-          << "state=" << int(state_) << ", sslState=" << sslState_
-          << ", events=" << eventFlags_;
+  VLOG(3) << "AsyncSSLSocket " << this << ": " << "fd " << fd_
+          << " successfully connected; " << "state=" << int(state_)
+          << ", sslState=" << sslState_ << ", events=" << eventFlags_;
 
   // Remember the EventBase we are attached to, before we start invoking any
   // callbacks (since the callbacks may call detachEventBase()).
@@ -1479,8 +1473,8 @@ void AsyncSSLSocket::scheduleConnectTimeout() {
 
 void AsyncSSLSocket::handleRead() noexcept {
   VLOG(5) << "AsyncSSLSocket::handleRead() this=" << this << ", fd=" << fd_
-          << ", state=" << int(state_) << ", "
-          << "sslState=" << sslState_ << ", events=" << eventFlags_;
+          << ", state=" << int(state_) << ", " << "sslState=" << sslState_
+          << ", events=" << eventFlags_;
   if (state_ < StateEnum::ESTABLISHED) {
     return AsyncSocket::handleRead();
   }
@@ -1549,13 +1543,11 @@ AsyncSocket::ReadResult AsyncSSLSocket::performReadSingle(
         // Peer has closed the connection for writing by sending the
         // close_notify alert. The underlying transport might not be closed, but
         // assume it is and return EOF.
-        VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", "
-                << "state=" << state_ << ", "
-                << "sslState=" << sslState_ << ", "
-                << "events=" << std::hex << eventFlags_ << "): "
-                << "bytes: " << bytes << ", "
-                << "error: " << error << ", "
-                << "received close_notify alert";
+        VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", " << "state=" << state_
+                << ", " << "sslState=" << sslState_ << ", "
+                << "events=" << std::hex << eventFlags_
+                << "): " << "bytes: " << bytes << ", " << "error: " << error
+                << ", " << "received close_notify alert";
         // AsyncSSLSocket interprets this as a READ_EOF.
         return ReadResult(0);
       }
@@ -1583,13 +1575,11 @@ AsyncSocket::ReadResult AsyncSSLSocket::performReadSingle(
       // return the head. Clear the rest.
       auto errError = ERR_get_error();
       ERR_clear_error();
-      VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", "
-              << "state=" << state_ << ", "
-              << "sslState=" << sslState_ << ", "
-              << "events=" << std::hex << eventFlags_ << "): "
-              << "bytes: " << bytes << ", "
-              << "error: " << error << ", "
-              << "errno: " << local_errno << ", "
+      VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", " << "state=" << state_
+              << ", " << "sslState=" << sslState_ << ", "
+              << "events=" << std::hex << eventFlags_
+              << "): " << "bytes: " << bytes << ", " << "error: " << error
+              << ", " << "errno: " << local_errno << ", "
               << "func: " << ERR_func_error_string(errError) << ", "
               << "reason: " << ERR_reason_error_string(errError);
       return ReadResult(
@@ -1665,8 +1655,8 @@ AsyncSocket::ReadResult AsyncSSLSocket::performReadMsg(
 
 void AsyncSSLSocket::handleWrite() noexcept {
   VLOG(5) << "AsyncSSLSocket::handleWrite() this=" << this << ", fd=" << fd_
-          << ", state=" << int(state_) << ", "
-          << "sslState=" << sslState_ << ", events=" << eventFlags_;
+          << ", state=" << int(state_) << ", " << "sslState=" << sslState_
+          << ", events=" << eventFlags_;
   if (state_ < StateEnum::ESTABLISHED) {
     return AsyncSocket::handleWrite();
   }
@@ -1694,8 +1684,7 @@ AsyncSocket::WriteResult AsyncSSLSocket::interpretSSLError(int rc, int error) {
     // don't support this and just fail the write.
     LOG(ERROR) << "AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
                << ", sslState=" << sslState_ << ", events=" << eventFlags_
-               << "): "
-               << "unsupported SSL renegotiation during write";
+               << "): " << "unsupported SSL renegotiation during write";
     return WriteResult(
         WRITE_ERROR,
         std::make_unique<SSLException>(SSLError::INVALID_RENEGOTIATION));
@@ -1705,8 +1694,8 @@ AsyncSocket::WriteResult AsyncSSLSocket::interpretSSLError(int rc, int error) {
     auto errError = ERR_get_error();
     ERR_clear_error();
     VLOG(3) << "ERROR: AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
-            << ", sslState=" << sslState_ << ", events=" << eventFlags_ << "): "
-            << "SSL error: " << error << ", errno: " << errno
+            << ", sslState=" << sslState_ << ", events=" << eventFlags_
+            << "): " << "SSL error: " << error << ", errno: " << errno
             << ", func: " << ERR_func_error_string(errError)
             << ", reason: " << ERR_reason_error_string(errError);
     return WriteResult(
diff --git a/folly/io/async/AsyncServerSocket.cpp b/folly/io/async/AsyncServerSocket.cpp
index a35dfa9d413..f8a8873cf07 100644
--- a/folly/io/async/AsyncServerSocket.cpp
+++ b/folly/io/async/AsyncServerSocket.cpp
@@ -464,7 +464,9 @@ void AsyncServerSocket::bind(uint16_t port) {
         "bad getaddrinfo");
   }
 
-  SCOPE_EXIT { freeaddrinfo(res0); };
+  SCOPE_EXIT {
+    freeaddrinfo(res0);
+  };
 
   auto setupAddress = [&](struct addrinfo* res) {
     auto s = netops::socket(res->ai_family, res->ai_socktype, res->ai_protocol);
diff --git a/folly/io/async/AsyncSocket.cpp b/folly/io/async/AsyncSocket.cpp
index 837038b8d23..9b90df86211 100644
--- a/folly/io/async/AsyncSocket.cpp
+++ b/folly/io/async/AsyncSocket.cpp
@@ -1774,7 +1774,9 @@ void AsyncSocket::writeImpl(
   auto* releaseIOBufCallback =
       callback ? callback->getReleaseIOBufCallback() : nullptr;
 
-  SCOPE_EXIT { releaseIOBuf(std::move(ioBuf), releaseIOBufCallback); };
+  SCOPE_EXIT {
+    releaseIOBuf(std::move(ioBuf), releaseIOBufCallback);
+  };
 
   totalAppBytesScheduledForWrite_ += totalBytes;
   if (ioBuf) {
@@ -3576,8 +3578,9 @@ void AsyncSocket::handleConnect() noexcept {
 }
 
 void AsyncSocket::timeoutExpired() noexcept {
-  VLOG(7) << "AsyncSocket " << this << ", fd " << fd_ << ": timeout expired: "
-          << "state=" << state_ << ", events=" << std::hex << eventFlags_;
+  VLOG(7) << "AsyncSocket " << this << ", fd " << fd_
+          << ": timeout expired: " << "state=" << state_
+          << ", events=" << std::hex << eventFlags_;
   DestructorGuard dg(this);
   eventBase_->dcheckIsInEventBaseThread();
 
diff --git a/folly/io/async/EventBase.cpp b/folly/io/async/EventBase.cpp
index 06c0e26b9be..55396782435 100644
--- a/folly/io/async/EventBase.cpp
+++ b/folly/io/async/EventBase.cpp
@@ -492,7 +492,9 @@ EventBase::LoopStatus EventBase::loopWithSuspension() {
   DCHECK_NE(evb_->getPollableFd(), -1)
       << "loopWithSuspension() is only supported for backends with pollable fd";
   loopMainSetup();
-  SCOPE_EXIT { loopMainCleanup(); };
+  SCOPE_EXIT {
+    loopMainCleanup();
+  };
   LoopOptions options;
   options.allowSuspension = true;
   return loopMain(EVLOOP_NONBLOCK, options);
@@ -873,7 +875,9 @@ void EventBase::runInEventBaseThreadAndWait(Func fn) noexcept {
 
   Baton<> ready;
   runInEventBaseThread([&ready, fn = std::move(fn)]() mutable {
-    SCOPE_EXIT { ready.post(); };
+    SCOPE_EXIT {
+      ready.post();
+    };
     // A trick to force the stored functor to be executed and then destructed
     // before posting the baton and waking the waiting thread.
     copy(std::move(fn))();
diff --git a/folly/io/async/EventBase.h b/folly/io/async/EventBase.h
index d13c85c0d1a..ac604ea74b1 100644
--- a/folly/io/async/EventBase.h
+++ b/folly/io/async/EventBase.h
@@ -939,7 +939,9 @@ class EventBase : public TimeoutManager,
   /// Implements the DrivableExecutor interface
   void drive() override {
     loopKeepAliveCount_.fetch_add(1, std::memory_order_relaxed);
-    SCOPE_EXIT { loopKeepAliveCount_.fetch_sub(1, std::memory_order_relaxed); };
+    SCOPE_EXIT {
+      loopKeepAliveCount_.fetch_sub(1, std::memory_order_relaxed);
+    };
     loopOnce();
   }
 
diff --git a/folly/io/async/EventBaseBackendBase.h b/folly/io/async/EventBaseBackendBase.h
index 644abab8ae7..1e28f6023f6 100644
--- a/folly/io/async/EventBaseBackendBase.h
+++ b/folly/io/async/EventBaseBackendBase.h
@@ -145,9 +145,7 @@ class EventBaseEvent {
 
   const struct event* getEvent() const { return &event_; }
 
-  struct event* getEvent() {
-    return &event_;
-  }
+  struct event* getEvent() { return &event_; }
 
   bool isEventRegistered() const {
     return EventUtil::isEventRegistered(&event_);
diff --git a/folly/io/async/NotificationQueue.h b/folly/io/async/NotificationQueue.h
index 44523394b03..d9db4911c98 100644
--- a/folly/io/async/NotificationQueue.h
+++ b/folly/io/async/NotificationQueue.h
@@ -416,7 +416,9 @@ class NotificationQueue {
    * unmodified.
    */
   bool tryConsume(MessageT& result) {
-    SCOPE_EXIT { syncSignalAndQueue(); };
+    SCOPE_EXIT {
+      syncSignalAndQueue();
+    };
 
     checkPid();
     std::unique_ptr<Node> data;
@@ -666,7 +668,9 @@ void NotificationQueue<MessageT>::Consumer::consumeMessages(
       queue_->syncSignalAndQueue();
     }
   };
-  SCOPE_EXIT { setActive(false, /* shouldLock = */ true); };
+  SCOPE_EXIT {
+    setActive(false, /* shouldLock = */ true);
+  };
   SCOPE_EXIT {
     if (numConsumed != nullptr) {
       *numConsumed = numProcessed;
@@ -833,7 +837,9 @@ bool NotificationQueue<MessageT>::Consumer::consumeUntilDrained(
 template <typename MessageT>
 template <typename F>
 void NotificationQueue<MessageT>::SimpleConsumer::consume(F&& foreach) {
-  SCOPE_EXIT { queue_.syncSignalAndQueue(); };
+  SCOPE_EXIT {
+    queue_.syncSignalAndQueue();
+  };
 
   queue_.checkPid();
 
diff --git a/folly/io/async/VirtualEventBase.cpp b/folly/io/async/VirtualEventBase.cpp
index f527a4c8e56..f9c4f2ab0b1 100644
--- a/folly/io/async/VirtualEventBase.cpp
+++ b/folly/io/async/VirtualEventBase.cpp
@@ -31,7 +31,9 @@ void VirtualEventBase::destroyImpl() noexcept {
     {
       // After destroyPromise_ is posted this object may be destroyed, so make
       // sure we release EventBase's keep-alive token before that.
-      SCOPE_EXIT { evb_.reset(); };
+      SCOPE_EXIT {
+        evb_.reset();
+      };
 
       clearCobTimeouts();
 
diff --git a/folly/io/async/fdsock/test/AsyncFdSocketTest.cpp b/folly/io/async/fdsock/test/AsyncFdSocketTest.cpp
index ec7be21f86a..8aa99f3ad2f 100644
--- a/folly/io/async/fdsock/test/AsyncFdSocketTest.cpp
+++ b/folly/io/async/fdsock/test/AsyncFdSocketTest.cpp
@@ -265,7 +265,9 @@ TEST_P(AsyncFdSocketSequenceRoundtripTest, WithDataSize) {
   // "ReadVec" path.
   test::ReadvCallback rcb(128, 3);
   // Avoid `readEOF` use-after-stack-scope in `~AsyncSocket`.
-  SCOPE_EXIT { recvSock_->setReadCB(nullptr); };
+  SCOPE_EXIT {
+    recvSock_->setReadCB(nullptr);
+  };
   recvSock_->setReadCB(&rcb);
 
   std::queue<
diff --git a/folly/io/async/ssl/OpenSSLUtils.cpp b/folly/io/async/ssl/OpenSSLUtils.cpp
index f4441cbd317..d852c14e7d0 100644
--- a/folly/io/async/ssl/OpenSSLUtils.cpp
+++ b/folly/io/async/ssl/OpenSSLUtils.cpp
@@ -153,12 +153,16 @@ static std::unordered_map<uint16_t, std::string> getOpenSSLCipherNames() {
   if ((ctx = SSL_CTX_new(meth)) == nullptr) {
     return ret;
   }
-  SCOPE_EXIT { SSL_CTX_free(ctx); };
+  SCOPE_EXIT {
+    SSL_CTX_free(ctx);
+  };
 
   if ((ssl = SSL_new(ctx)) == nullptr) {
     return ret;
   }
-  SCOPE_EXIT { SSL_free(ssl); };
+  SCOPE_EXIT {
+    SSL_free(ssl);
+  };
 
   STACK_OF(SSL_CIPHER)* sk = SSL_get_ciphers(ssl);
   for (int i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
diff --git a/folly/io/async/test/AsyncSSLSocketTest.cpp b/folly/io/async/test/AsyncSSLSocketTest.cpp
index 6084f1d15fd..ffbc9c64632 100644
--- a/folly/io/async/test/AsyncSSLSocketTest.cpp
+++ b/folly/io/async/test/AsyncSSLSocketTest.cpp
@@ -1249,7 +1249,9 @@ TEST(AsyncSSLSocketTest, SSLParseClientHelloOnePacket) {
   cursor.write<uint32_t>(0);
 
   SSL* ssl = ctx->createSSL();
-  SCOPE_EXIT { SSL_free(ssl); };
+  SCOPE_EXIT {
+    SSL_free(ssl);
+  };
   AsyncSSLSocket::UniquePtr sock(
       new AsyncSSLSocket(ctx, &eventBase, fds[0], true));
   sock->enableClientHelloParsing();
@@ -1289,7 +1291,9 @@ TEST(AsyncSSLSocketTest, SSLParseClientHelloTwoPackets) {
   cursor.write<uint32_t>(0);
 
   SSL* ssl = ctx->createSSL();
-  SCOPE_EXIT { SSL_free(ssl); };
+  SCOPE_EXIT {
+    SSL_free(ssl);
+  };
   AsyncSSLSocket::UniquePtr sock(
       new AsyncSSLSocket(ctx, &eventBase, fds[0], true));
   sock->enableClientHelloParsing();
@@ -1347,7 +1351,9 @@ TEST(AsyncSSLSocketTest, SSLParseClientHelloMultiplePackets) {
   cursor.write<uint32_t>(0);
 
   SSL* ssl = ctx->createSSL();
-  SCOPE_EXIT { SSL_free(ssl); };
+  SCOPE_EXIT {
+    SSL_free(ssl);
+  };
   AsyncSSLSocket::UniquePtr sock(
       new AsyncSSLSocket(ctx, &eventBase, fds[0], true));
   sock->enableClientHelloParsing();
diff --git a/folly/io/async/test/AsyncSSLSocketTest.h b/folly/io/async/test/AsyncSSLSocketTest.h
index 2e7748f19b5..11ae0cda54a 100644
--- a/folly/io/async/test/AsyncSSLSocketTest.h
+++ b/folly/io/async/test/AsyncSSLSocketTest.h
@@ -764,9 +764,7 @@ class BlockingWriteClient : private AsyncSSLSocket::HandshakeCB,
     socket_->sslConn(this, std::chrono::milliseconds(100));
   }
 
-  struct iovec* getIovec() const {
-    return iov_.get();
-  }
+  struct iovec* getIovec() const { return iov_.get(); }
   uint32_t getIovecCount() const { return iovCount_; }
 
  private:
@@ -813,9 +811,9 @@ class BlockingWriteServer : private AsyncSSLSocket::HandshakeCB,
                << ": rc=" << rc;
       }
       if (iov[n].iov_len > bytesLeft) {
-        FAIL() << "server did not read enough data: "
-               << "ended at byte " << bytesLeft << "/" << iov[n].iov_len
-               << " in iovec " << n << "/" << count;
+        FAIL() << "server did not read enough data: " << "ended at byte "
+               << bytesLeft << "/" << iov[n].iov_len << " in iovec " << n << "/"
+               << count;
       }
 
       idx += iov[n].iov_len;
diff --git a/folly/io/async/test/AsyncSocketTest.h b/folly/io/async/test/AsyncSocketTest.h
index e5e31e28168..b12fb1db263 100644
--- a/folly/io/async/test/AsyncSocketTest.h
+++ b/folly/io/async/test/AsyncSocketTest.h
@@ -533,7 +533,9 @@ class TestServer {
           errno);
     }
 
-    SCOPE_EXIT { freeaddrinfo(res); };
+    SCOPE_EXIT {
+      freeaddrinfo(res);
+    };
 
     if (bufSize > 0) {
       folly::netops::setsockopt(
diff --git a/folly/io/async/test/AsyncSocketTest2.cpp b/folly/io/async/test/AsyncSocketTest2.cpp
index f8bf7e4ad3b..e1bd255b2a2 100644
--- a/folly/io/async/test/AsyncSocketTest2.cpp
+++ b/folly/io/async/test/AsyncSocketTest2.cpp
@@ -4819,7 +4819,9 @@ TEST_F(AsyncSocketByteEventTest, FailUnixSocket) {
   EXPECT_EQ(netops::socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
   ASSERT_NE(fd[0], NetworkSocket());
   ASSERT_NE(fd[1], NetworkSocket());
-  SCOPE_EXIT { netops::close(fd[1]); };
+  SCOPE_EXIT {
+    netops::close(fd[1]);
+  };
 
   EXPECT_EQ(netops::set_socket_non_blocking(fd[0]), 0);
   EXPECT_EQ(netops::set_socket_non_blocking(fd[1]), 0);
@@ -9391,7 +9393,9 @@ TEST(AsyncSocketTest, SendMessageAncillaryData) {
   // "Server" socket
   auto sfd = fds[1];
   ASSERT_NE(sfd, NetworkSocket());
-  SCOPE_EXIT { netops::close(sfd); };
+  SCOPE_EXIT {
+    netops::close(sfd);
+  };
 
   // Instantiate AsyncSocket object for the connected socket
   EventBase evb;
@@ -9468,7 +9472,9 @@ TEST(AsyncSocketTest, SendMessageAncillaryData) {
   int fd = 0;
   memcpy(&fd, CMSG_DATA(&r_u.cmh), sizeof(int));
   ASSERT_NE(fd, 0);
-  SCOPE_EXIT { close(fd); };
+  SCOPE_EXIT {
+    close(fd);
+  };
 
   std::vector<uint8_t> transferredMagicString(magicString.length() + 1, 0);
 
@@ -9616,7 +9622,9 @@ TEST(AsyncSocketTest, UnixDomainSocketErrMessageCB) {
   EXPECT_EQ(netops::socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
   ASSERT_NE(fd[0], NetworkSocket());
   ASSERT_NE(fd[1], NetworkSocket());
-  SCOPE_EXIT { netops::close(fd[1]); };
+  SCOPE_EXIT {
+    netops::close(fd[1]);
+  };
 
   EXPECT_EQ(netops::set_socket_non_blocking(fd[0]), 0);
   EXPECT_EQ(netops::set_socket_non_blocking(fd[1]), 0);
diff --git a/folly/io/async/test/EventHandlerTest.cpp b/folly/io/async/test/EventHandlerTest.cpp
index b5337692431..fce58df0ebb 100644
--- a/folly/io/async/test/EventHandlerTest.cpp
+++ b/folly/io/async/test/EventHandlerTest.cpp
@@ -202,7 +202,9 @@ class EventHandlerOobTest : public ::testing::Test {
     clientThread = std::thread([serverPortFuture = serverReady.get_future(),
                                 clientOps]() mutable {
       int clientFd = socket(AF_INET, SOCK_STREAM, 0);
-      SCOPE_EXIT { close(clientFd); };
+      SCOPE_EXIT {
+        close(clientFd);
+      };
       struct hostent* he{nullptr};
       struct sockaddr_in server;
 
@@ -232,7 +234,9 @@ class EventHandlerOobTest : public ::testing::Test {
   void acceptConn() {
     // make the server.
     int listenfd = socket(AF_INET, SOCK_STREAM, 0);
-    SCOPE_EXIT { close(listenfd); };
+    SCOPE_EXIT {
+      close(listenfd);
+    };
     PCHECK(listenfd != -1) << "unable to open socket";
 
     struct sockaddr_in sin;
diff --git a/folly/io/async/test/RequestContextBenchmark.cpp b/folly/io/async/test/RequestContextBenchmark.cpp
index a2b4265ae33..c18853754ee 100644
--- a/folly/io/async/test/RequestContextBenchmark.cpp
+++ b/folly/io/async/test/RequestContextBenchmark.cpp
@@ -256,8 +256,7 @@ void benches() {
       << std::endl;
   for (int i : nthr) {
     std::cout << "============================== " << std::setw(2) << i
-              << " threads "
-              << "==============================" << std::endl;
+              << " threads " << "==============================" << std::endl;
     const uint64_t ops = FLAGS_ops;
     std::cout << "hasContextData                  ";
     bench_hasContextData(i, ops, true);
diff --git a/folly/io/async/test/TimeUtil.cpp b/folly/io/async/test/TimeUtil.cpp
index f654d4f7708..ed2366065b9 100644
--- a/folly/io/async/test/TimeUtil.cpp
+++ b/folly/io/async/test/TimeUtil.cpp
@@ -121,7 +121,9 @@ static int64_t determineSchedstatUnits() {
                << configPath;
     return -1;
   }
-  SCOPE_EXIT { fclose(f); };
+  SCOPE_EXIT {
+    fclose(f);
+  };
 
   int64_t hz = -1;
   char buf[1024];
diff --git a/folly/io/async/test/WriteFlagsTest.cpp b/folly/io/async/test/WriteFlagsTest.cpp
index 0993255151d..2fa2500e53e 100644
--- a/folly/io/async/test/WriteFlagsTest.cpp
+++ b/folly/io/async/test/WriteFlagsTest.cpp
@@ -16,7 +16,7 @@
 
 #include <folly/io/async/AsyncTransport.h>
 
-//#include <folly/io/async/test/MockAsyncTransport.h>
+// #include <folly/io/async/test/MockAsyncTransport.h>
 #include <folly/portability/GTest.h>
 
 namespace folly {
diff --git a/folly/io/test/QueueAppenderBenchmark.cpp b/folly/io/test/QueueAppenderBenchmark.cpp
index bf02878c162..16e45a4fa62 100644
--- a/folly/io/test/QueueAppenderBenchmark.cpp
+++ b/folly/io/test/QueueAppenderBenchmark.cpp
@@ -64,13 +64,17 @@ void runPushBenchmark(int64_t iters, const std::string& str) {
 
 BENCHMARK(push_64b, iters) {
   std::string data;
-  BENCHMARK_SUSPEND { data = std::string(64, 'f'); }
+  BENCHMARK_SUSPEND {
+    data = std::string(64, 'f');
+  }
   runPushBenchmark(iters, data);
 }
 
 BENCHMARK(push_1024b, iters) {
   std::string data;
-  BENCHMARK_SUSPEND { data = std::string(1024, 'b'); }
+  BENCHMARK_SUSPEND {
+    data = std::string(1024, 'b');
+  }
   runPushBenchmark(iters, data);
 }
 
@@ -95,7 +99,9 @@ BENCHMARK(append, iters) {
 
 void preallocate_postallocate_bench(int64_t iters, size_t size) {
   std::string data;
-  BENCHMARK_SUSPEND { data = std::string(size, 'f'); }
+  BENCHMARK_SUSPEND {
+    data = std::string(size, 'f');
+  }
   while (iters--) {
     folly::IOBufQueue queue;
     for (size_t i = 0; i < kBenchmarkSize; ++i) {
diff --git a/folly/json/json.cpp b/folly/json/json.cpp
index 107df940368..01f3f2e88b4 100644
--- a/folly/json/json.cpp
+++ b/folly/json/json.cpp
@@ -682,7 +682,7 @@ std::string parseString(Input& in) {
     if (*in == '\\') {
       ++in;
       switch (*in) {
-        // clang-format off
+          // clang-format off
         case '\"':    ret.push_back('\"'); ++in; break;
         case '\\':    ret.push_back('\\'); ++in; break;
         case '/':     ret.push_back('/');  ++in; break;
@@ -935,7 +935,7 @@ void escapeStringImpl(
       out.append(buf, 2);
     } else if (*p <= 0x1f) {
       switch (*p) {
-        // clang-format off
+          // clang-format off
         case '\b': out.append("\\b"); p++; break;
         case '\f': out.append("\\f"); p++; break;
         case '\n': out.append("\\n"); p++; break;
diff --git a/folly/lang/Bits.h b/folly/lang/Bits.h
index f51f41d3359..379e2a289ac 100644
--- a/folly/lang/Bits.h
+++ b/folly/lang/Bits.h
@@ -230,11 +230,13 @@ namespace detail {
 template <size_t Size>
 struct uint_types_by_size;
 
-#define FB_GEN(sz, fn)                                                      \
-  static inline uint##sz##_t byteswap_gen(uint##sz##_t v) { return fn(v); } \
-  template <>                                                               \
-  struct uint_types_by_size<sz / 8> {                                       \
-    using type = uint##sz##_t;                                              \
+#define FB_GEN(sz, fn)                                      \
+  static inline uint##sz##_t byteswap_gen(uint##sz##_t v) { \
+    return fn(v);                                           \
+  }                                                         \
+  template <>                                               \
+  struct uint_types_by_size<sz / 8> {                       \
+    using type = uint##sz##_t;                              \
   };
 
 FB_GEN(8, uint8_t)
@@ -276,7 +278,9 @@ struct EndianInt {
 // ntohs, htons == big16
 // ntohl, htonl == big32
 #define FB_GEN1(fn, t, sz) \
-  static t fn##sz(t x) { return fn<t>(x); }
+  static t fn##sz(t x) {   \
+    return fn<t>(x);       \
+  }
 
 #define FB_GEN2(t, sz) \
   FB_GEN1(swap, t, sz) \
diff --git a/folly/lang/Exception.h b/folly/lang/Exception.h
index 2d87c128795..19451e99bfd 100644
--- a/folly/lang/Exception.h
+++ b/folly/lang/Exception.h
@@ -151,7 +151,7 @@ template <
     typename... A,
     typename FD = std::remove_pointer_t<std::decay_t<F>>,
     std::enable_if_t<!std::is_function<FD>::value, int> = 0,
-    typename R = decltype(FOLLY_DECLVAL(F &&)(FOLLY_DECLVAL(A &&)...))>
+    typename R = decltype(FOLLY_DECLVAL(F&&)(FOLLY_DECLVAL(A&&)...))>
 FOLLY_NOINLINE FOLLY_COLD R invoke_cold(F&& f, A&&... a) //
     noexcept(noexcept(static_cast<F&&>(f)(static_cast<A&&>(a)...))) {
   return static_cast<F&&>(f)(static_cast<A&&>(a)...);
@@ -161,7 +161,7 @@ template <
     typename... A,
     typename FD = std::remove_pointer_t<std::decay_t<F>>,
     std::enable_if_t<std::is_function<FD>::value, int> = 0,
-    typename R = decltype(FOLLY_DECLVAL(F &&)(FOLLY_DECLVAL(A &&)...))>
+    typename R = decltype(FOLLY_DECLVAL(F&&)(FOLLY_DECLVAL(A&&)...))>
 FOLLY_ERASE R invoke_cold(F&& f, A&&... a) //
     noexcept(noexcept(f(static_cast<A&&>(a)...))) {
   return f(static_cast<A&&>(a)...);
@@ -233,8 +233,8 @@ template <
     typename Catch,
     typename... CatchA,
     typename R = std::common_type_t<
-        decltype(FOLLY_DECLVAL(Try &&)()),
-        decltype(FOLLY_DECLVAL(Catch &&)(
+        decltype(FOLLY_DECLVAL(Try&&)()),
+        decltype(FOLLY_DECLVAL(Catch&&)(
             FOLLY_DECLVAL(E&), FOLLY_DECLVAL(CatchA&&)...))>>
 FOLLY_ERASE_TRYCATCH R catch_exception(Try&& t, Catch&& c, CatchA&&... a) {
 #if FOLLY_HAS_EXCEPTIONS
@@ -276,8 +276,8 @@ template <
     typename Catch,
     typename... CatchA,
     typename R = std::common_type_t<
-        decltype(FOLLY_DECLVAL(Try &&)()),
-        decltype(FOLLY_DECLVAL(Catch &&)(FOLLY_DECLVAL(CatchA &&)...))>>
+        decltype(FOLLY_DECLVAL(Try&&)()),
+        decltype(FOLLY_DECLVAL(Catch&&)(FOLLY_DECLVAL(CatchA&&)...))>>
 FOLLY_ERASE_TRYCATCH R
 catch_exception(Try&& t, Catch&& c, CatchA&&... a) noexcept(
     noexcept(static_cast<Catch&&>(c)(static_cast<CatchA&&>(a)...))) {
diff --git a/folly/lang/PropagateConst.h b/folly/lang/PropagateConst.h
index 13af1094738..dcf60099a1a 100644
--- a/folly/lang/PropagateConst.h
+++ b/folly/lang/PropagateConst.h
@@ -160,7 +160,7 @@ class propagate_const {
       typename = std::enable_if_t<
           std::is_pointer<OtherPointer>::value ||
           std::is_convertible<OtherPointer, element_type const*>::value>>
-  constexpr operator element_type const *() const {
+  constexpr operator element_type const*() const {
     return get();
   }
 
diff --git a/folly/logging/test/LoggerTest.cpp b/folly/logging/test/LoggerTest.cpp
index c91ebf04ff0..159a06cf719 100644
--- a/folly/logging/test/LoggerTest.cpp
+++ b/folly/logging/test/LoggerTest.cpp
@@ -255,8 +255,7 @@ TEST_F(LoggerTest, streamingArgs) {
   messages.clear();
 
   // Test with both function-style and streaming arguments
-  FB_LOG(logger_, WARN, "foo=", foo) << " hello, "
-                                     << "world: " << 34;
+  FB_LOG(logger_, WARN, "foo=", foo) << " hello, " << "world: " << 34;
   ASSERT_EQ(1, messages.size());
   EXPECT_EQ("foo=bar hello, world: 34", messages[0].first.getMessage());
   EXPECT_EQ("LoggerTest.cpp", pathBasename(messages[0].first.getFileName()));
diff --git a/folly/logging/xlog.h b/folly/logging/xlog.h
index aba3128efea..5478047d569 100644
--- a/folly/logging/xlog.h
+++ b/folly/logging/xlog.h
@@ -647,7 +647,9 @@ FOLLY_EXPORT FOLLY_ALWAYS_INLINE bool xlogFirstNExactImpl(std::size_t n) {
   FOLLY_CONSTEVAL inline StringPiece getXlogCategoryName(StringPiece, int) { \
     return category;                                                         \
   }                                                                          \
-  FOLLY_CONSTEVAL inline bool isXlogCategoryOverridden(int) { return true; } \
+  FOLLY_CONSTEVAL inline bool isXlogCategoryOverridden(int) {                \
+    return true;                                                             \
+  }                                                                          \
   }                                                                          \
   }                                                                          \
   }                                                                          \
diff --git a/folly/memory/test/SanitizeAddressTest.cpp b/folly/memory/test/SanitizeAddressTest.cpp
index 246a799deeb..b75242a0de0 100644
--- a/folly/memory/test/SanitizeAddressTest.cpp
+++ b/folly/memory/test/SanitizeAddressTest.cpp
@@ -31,7 +31,7 @@ TEST_F(SanitizeAddressTest, asan_poison) {
   // malloc
 
   auto const addr =
-      static_cast<opaque*>(operator new (size, std::align_val_t{page}));
+      static_cast<opaque*>(operator new(size, std::align_val_t{page}));
 
   EXPECT_EQ(nullptr, folly::asan_region_is_poisoned(addr, size));
   EXPECT_EQ(0, folly::asan_address_is_poisoned(addr + offs));
@@ -58,7 +58,7 @@ TEST_F(SanitizeAddressTest, asan_poison) {
 
   // free
 
-  operator delete (addr, size, std::align_val_t{page});
+  operator delete(addr, size, std::align_val_t{page});
   EXPECT_EQ(
       folly::kIsSanitizeAddress ? addr : nullptr,
       folly::asan_region_is_poisoned(addr, size));
diff --git a/folly/net/NetOps.cpp b/folly/net/NetOps.cpp
index 1f21d77d1ca..78ce7ec04e3 100644
--- a/folly/net/NetOps.cpp
+++ b/folly/net/NetOps.cpp
@@ -383,7 +383,9 @@ ssize_t recvmsg(NetworkSocket s, msghdr* message, int flags) {
   msg.dwFlags = 0;
   msg.dwBufferCount = (DWORD)message->msg_iovlen;
   msg.lpBuffers = new WSABUF[message->msg_iovlen];
-  SCOPE_EXIT { delete[] msg.lpBuffers; };
+  SCOPE_EXIT {
+    delete[] msg.lpBuffers;
+  };
   for (size_t i = 0; i < message->msg_iovlen; i++) {
     msg.lpBuffers[i].buf = (CHAR*)message->msg_iov[i].iov_base;
     msg.lpBuffers[i].len = (ULONG)message->msg_iov[i].iov_len;
@@ -506,7 +508,9 @@ ssize_t send(NetworkSocket s, const void* buf, size_t len, int flags) {
   msg.dwFlags = flags;
   msg.dwBufferCount = (DWORD)message->msg_iovlen;
   msg.lpBuffers = new WSABUF[message->msg_iovlen];
-  SCOPE_EXIT { delete[] msg.lpBuffers; };
+  SCOPE_EXIT {
+    delete[] msg.lpBuffers;
+  };
   for (size_t i = 0; i < message->msg_iovlen; i++) {
     msg.lpBuffers[i].buf = (CHAR*)message->msg_iov[i].iov_base;
     msg.lpBuffers[i].len = (ULONG)message->msg_iov[i].iov_len;
diff --git a/folly/portability/Stdio.cpp b/folly/portability/Stdio.cpp
index 0b495fda336..b836f6d8dc3 100644
--- a/folly/portability/Stdio.cpp
+++ b/folly/portability/Stdio.cpp
@@ -27,7 +27,9 @@ extern "C" {
 int dprintf(int fd, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
-  SCOPE_EXIT { va_end(args); };
+  SCOPE_EXIT {
+    va_end(args);
+  };
 
   int ret = vsnprintf(nullptr, 0, fmt, args);
   if (ret <= 0) {
@@ -35,7 +37,9 @@ int dprintf(int fd, const char* fmt, ...) {
   }
   size_t len = size_t(ret);
   char* buf = new char[len + 1];
-  SCOPE_EXIT { delete[] buf; };
+  SCOPE_EXIT {
+    delete[] buf;
+  };
   if (size_t(vsnprintf(buf, len + 1, fmt, args)) == len &&
       write(fd, buf, len) == ssize_t(len)) {
     return ret;
diff --git a/folly/small_vector.h b/folly/small_vector.h
index 847bdc5bdb9..31b874a2e9b 100644
--- a/folly/small_vector.h
+++ b/folly/small_vector.h
@@ -679,8 +679,8 @@ class small_vector
    * of in-place vs. heap between this and o.
    */
   void swap(small_vector& o) noexcept(
-      std::is_nothrow_move_constructible<Value>::value&&
-          std::is_nothrow_swappable_v<Value>) {
+      std::is_nothrow_move_constructible<Value>::value &&
+      std::is_nothrow_swappable_v<Value>) {
     using std::swap; // Allow ADL on swap for our value_type.
 
     if (this->isExtern() && o.isExtern()) {
@@ -1171,8 +1171,7 @@ class small_vector
     if (newSize <= capacity()) {
       return;
     }
-    makeSizeInternal(
-        newSize, false, [](void*) { assume_unreachable(); }, 0);
+    makeSizeInternal(newSize, false, [](void*) { assume_unreachable(); }, 0);
   }
 
   template <typename EmplaceFunc>
diff --git a/folly/sorted_vector_types.h b/folly/sorted_vector_types.h
index 7d4cb4cf49a..1c82edbc65b 100644
--- a/folly/sorted_vector_types.h
+++ b/folly/sorted_vector_types.h
@@ -715,8 +715,8 @@ class sorted_vector_set : detail::growth_policy_wrapper<GrowthPolicy> {
   }
 
   void swap(sorted_vector_set& o) noexcept(
-      std::is_nothrow_swappable_v<Compare>&& noexcept(
-          std::declval<Container&>().swap(o.m_.cont_))) {
+      std::is_nothrow_swappable_v<Compare> &&
+      noexcept(std::declval<Container&>().swap(o.m_.cont_))) {
     using std::swap; // Allow ADL for swap(); fall back to std::swap().
     Compare& a = m_;
     Compare& b = o.m_;
@@ -760,22 +760,22 @@ class sorted_vector_set : detail::growth_policy_wrapper<GrowthPolicy> {
     explicit EBO(const Compare& c, const Allocator& alloc) noexcept(
         std::is_nothrow_default_constructible<Container>::value)
         : Compare(c), cont_(alloc) {}
-    EBO(const EBO& other, const Allocator& alloc)
-    noexcept(std::is_nothrow_constructible<
-             Container,
-             const Container&,
-             const Allocator&>::value)
+    EBO(const EBO& other, const Allocator& alloc) noexcept(
+        std::is_nothrow_constructible<
+            Container,
+            const Container&,
+            const Allocator&>::value)
         : Compare(static_cast<const Compare&>(other)),
           cont_(other.cont_, alloc) {}
-    EBO(EBO&& other, const Allocator& alloc)
-    noexcept(std::is_nothrow_constructible<
-             Container,
-             Container&&,
-             const Allocator&>::value)
+    EBO(EBO&& other, const Allocator& alloc) noexcept(
+        std::is_nothrow_constructible<
+            Container,
+            Container&&,
+            const Allocator&>::value)
         : Compare(static_cast<Compare&&>(other)),
           cont_(std::move(other.cont_), alloc) {}
-    EBO(const Compare& c, Container&& cont)
-    noexcept(std::is_nothrow_move_constructible<Container>::value)
+    EBO(const Compare& c, Container&& cont) noexcept(
+        std::is_nothrow_move_constructible<Container>::value)
         : Compare(c), cont_(std::move(cont)) {}
     Container cont_;
   } m_;
@@ -1450,22 +1450,22 @@ class sorted_vector_map : detail::growth_policy_wrapper<GrowthPolicy> {
     explicit EBO(const value_compare& c, const Allocator& alloc) noexcept(
         std::is_nothrow_default_constructible<Container>::value)
         : value_compare(c), cont_(alloc) {}
-    EBO(const EBO& other, const Allocator& alloc)
-    noexcept(std::is_nothrow_constructible<
-             Container,
-             const Container&,
-             const Allocator&>::value)
+    EBO(const EBO& other, const Allocator& alloc) noexcept(
+        std::is_nothrow_constructible<
+            Container,
+            const Container&,
+            const Allocator&>::value)
         : value_compare(static_cast<const value_compare&>(other)),
           cont_(other.cont_, alloc) {}
-    EBO(EBO&& other, const Allocator& alloc)
-    noexcept(std::is_nothrow_constructible<
-             Container,
-             Container&&,
-             const Allocator&>::value)
+    EBO(EBO&& other, const Allocator& alloc) noexcept(
+        std::is_nothrow_constructible<
+            Container,
+            Container&&,
+            const Allocator&>::value)
         : value_compare(static_cast<value_compare&&>(other)),
           cont_(std::move(other.cont_), alloc) {}
-    EBO(const Compare& c, Container&& cont)
-    noexcept(std::is_nothrow_move_constructible<Container>::value)
+    EBO(const Compare& c, Container&& cont) noexcept(
+        std::is_nothrow_move_constructible<Container>::value)
         : value_compare(c), cont_(std::move(cont)) {}
     Container cont_;
   } m_;
diff --git a/folly/ssl/OpenSSLCertUtils.cpp b/folly/ssl/OpenSSLCertUtils.cpp
index e0b1d8c32b3..1a1e5daff89 100644
--- a/folly/ssl/OpenSSLCertUtils.cpp
+++ b/folly/ssl/OpenSSLCertUtils.cpp
@@ -110,7 +110,9 @@ std::vector<std::string> OpenSSLCertUtils::getSubjectAltNames(X509& x509) {
   if (!names) {
     return {};
   }
-  SCOPE_EXIT { sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free); };
+  SCOPE_EXIT {
+    sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
+  };
 
   std::vector<std::string> ret;
   auto count = sk_GENERAL_NAME_num(names);
diff --git a/folly/stats/MultiLevelTimeSeries.h b/folly/stats/MultiLevelTimeSeries.h
index 95f80d398b6..65dbb853a14 100644
--- a/folly/stats/MultiLevelTimeSeries.h
+++ b/folly/stats/MultiLevelTimeSeries.h
@@ -132,8 +132,8 @@ class MultiLevelTimeSeries {
       }
     }
     // We should always have an all-time level, so this is never reached.
-    LOG(FATAL) << "No level of timeseries covers internval"
-               << " from " << start.time_since_epoch().count() << " to now";
+    LOG(FATAL) << "No level of timeseries covers internval" << " from "
+               << start.time_since_epoch().count() << " to now";
     return levels_.back();
   }
 
diff --git a/folly/stats/test/TimeSeriesTest.cpp b/folly/stats/test/TimeSeriesTest.cpp
index f0ce4ac203a..4cb4b6cf7dd 100644
--- a/folly/stats/test/TimeSeriesTest.cpp
+++ b/folly/stats/test/TimeSeriesTest.cpp
@@ -441,7 +441,9 @@ TEST(BucketedTimeSeries, avgTypeConversion) {
     // but the average fits in an int64_t
     BucketedTimeSeries<double> ts(60, seconds(600));
     uint64_t value = 0x3fffffffffffffff;
-    FOR_EACH_RANGE (i, 0, 16) { ts.addValue(seconds(0), value); }
+    FOR_EACH_RANGE (i, 0, 16) {
+      ts.addValue(seconds(0), value);
+    }
 
     EXPECT_DOUBLE_EQ(value, ts.avg());
     EXPECT_DOUBLE_EQ(value, ts.avg<float>());
@@ -454,7 +456,9 @@ TEST(BucketedTimeSeries, avgTypeConversion) {
   {
     // Test BucketedTimeSeries with a smaller integer type
     BucketedTimeSeries<int16_t> ts(60, seconds(600));
-    FOR_EACH_RANGE (i, 0, 101) { ts.addValue(seconds(0), i); }
+    FOR_EACH_RANGE (i, 0, 101) {
+      ts.addValue(seconds(0), i);
+    }
 
     EXPECT_DOUBLE_EQ(50.0, ts.avg());
     EXPECT_DOUBLE_EQ(50.0, ts.avg<float>());
diff --git a/folly/synchronization/AtomicNotification-inl.h b/folly/synchronization/AtomicNotification-inl.h
index ab3b64d3175..c821efef9bb 100644
--- a/folly/synchronization/AtomicNotification-inl.h
+++ b/folly/synchronization/AtomicNotification-inl.h
@@ -55,8 +55,7 @@ void atomic_wait_impl(
 template <template <typename...> class Atom, typename Integer, typename... Args>
 void atomic_wait_impl(const Atom<Integer, Args...>* atomic, Integer old) {
   static_assert(!std::is_same<Integer, std::uint32_t>{}, "");
-  parkingLot.park(
-      atomic, -1, [&] { return atomic->load() == old; }, [] {});
+  parkingLot.park(atomic, -1, [&] { return atomic->load() == old; }, [] {});
 }
 
 template <
diff --git a/folly/synchronization/DistributedMutex-inl.h b/folly/synchronization/DistributedMutex-inl.h
index d23a8a0d1cf..7a432504d24 100644
--- a/folly/synchronization/DistributedMutex-inl.h
+++ b/folly/synchronization/DistributedMutex-inl.h
@@ -400,7 +400,9 @@ class RequestWithReturn {
     // note that the invariant here is that this function is only called if the
     // requesting thread had it's critical section combined, and the value_
     // member constructed through detach()
-    SCOPE_EXIT { value_.~ReturnType(); };
+    SCOPE_EXIT {
+      value_.~ReturnType();
+    };
     return std::move(value_);
   }
 
@@ -1054,7 +1056,9 @@ auto DistributedMutex<Atomic, TimePublishing>::lock_combine(Func func)
     // to avoid having to play a return-value dance when the combinable
     // returns void, we use a scope exit to perform the unlock after the
     // function return has been processed
-    SCOPE_EXIT { unlock(std::move(state)); };
+    SCOPE_EXIT {
+      unlock(std::move(state));
+    };
     return func();
   }
 
@@ -1087,7 +1091,9 @@ DistributedMutex<Atomic, TimePublishing>::try_lock_combine_for(
     const std::chrono::duration<Rep, Period>& duration, Func func) {
   auto state = try_lock_for(duration);
   if (state) {
-    SCOPE_EXIT { unlock(std::move(state)); };
+    SCOPE_EXIT {
+      unlock(std::move(state));
+    };
     return func();
   }
 
@@ -1101,7 +1107,9 @@ DistributedMutex<Atomic, TimePublishing>::try_lock_combine_until(
     const std::chrono::time_point<Clock, Duration>& deadline, Func func) {
   auto state = try_lock_until(deadline);
   if (state) {
-    SCOPE_EXIT { unlock(std::move(state)); };
+    SCOPE_EXIT {
+      unlock(std::move(state));
+    };
     return func();
   }
 
diff --git a/folly/synchronization/HazptrDomain.h b/folly/synchronization/HazptrDomain.h
index 86ae0bc2330..99af58c4fed 100644
--- a/folly/synchronization/HazptrDomain.h
+++ b/folly/synchronization/HazptrDomain.h
@@ -757,9 +757,8 @@ class hazptr_domain {
       uintptr_t ftag, size_t shard, int count) {
     static std::atomic<uint64_t> warning_count{0};
     if ((warning_count++ % 10000) == 0) {
-      LOG(WARNING) << "Hazptr retired list too large:"
-                   << " ftag=" << ftag << " shard=" << shard
-                   << " count=" << count;
+      LOG(WARNING) << "Hazptr retired list too large:" << " ftag=" << ftag
+                   << " shard=" << shard << " count=" << count;
     }
   }
 
diff --git a/folly/synchronization/test/HazptrTest.cpp b/folly/synchronization/test/HazptrTest.cpp
index 8882260cfb2..b28e01cd288 100644
--- a/folly/synchronization/test/HazptrTest.cpp
+++ b/folly/synchronization/test/HazptrTest.cpp
@@ -1601,8 +1601,7 @@ const int sizes[] = {10, 20};
 void benches() {
   for (int i : nthr) {
     std::cout << "================================ " << std::setw(2) << i
-              << " threads "
-              << "================================" << std::endl;
+              << " threads " << "================================" << std::endl;
     std::cout << "10x construct/destruct hazptr_holder          ";
     holder_bench("", i);
     std::cout << "10x construct/destruct hazptr_array<1>        ";
diff --git a/folly/synchronization/test/ParkingLotTest.cpp b/folly/synchronization/test/ParkingLotTest.cpp
index 075cf98416c..be6d44a189a 100644
--- a/folly/synchronization/test/ParkingLotTest.cpp
+++ b/folly/synchronization/test/ParkingLotTest.cpp
@@ -32,12 +32,10 @@ TEST(ParkingLot, multilot) {
   folly::Baton<> lb;
 
   std::thread small([&]() {
-    smalllot.park(
-        0, false, [] { return true; }, [&]() { sb.post(); });
+    smalllot.park(0, false, [] { return true; }, [&]() { sb.post(); });
   });
   std::thread large([&]() {
-    largelot.park(
-        0, true, [] { return true; }, [&]() { lb.post(); });
+    largelot.park(0, true, [] { return true; }, [&]() { lb.post(); });
   });
   sb.wait();
   lb.wait();
@@ -74,8 +72,7 @@ TEST(ParkingLot, StressTestPingPong) {
     while (!testDone.load(std::memory_order_relaxed)) {
       // wait while the atomic is still equal to c, the other thread unblocks us
       // because it signals before spinning itself
-      lot.park(
-          &one, -1, [&]() { return one.load() == local; }, []() {});
+      lot.park(&one, -1, [&]() { return one.load() == local; }, []() {});
       local = one.load(std::memory_order_acquire);
       two.store(local, std::memory_order_release);
     }
@@ -115,8 +112,7 @@ TEST(ParkingLot, LargeWord) {
   ParkingLot<uint64_t> lot;
   std::atomic<uint64_t> w{0};
 
-  lot.park(
-      0, false, [&]() { return w == 1; }, []() {});
+  lot.park(0, false, [&]() { return w == 1; }, []() {});
 
   // Validate should return false, will hang otherwise.
 }
diff --git a/folly/synchronization/test/SmallLocksBenchmark.cpp b/folly/synchronization/test/SmallLocksBenchmark.cpp
index 4d13a3c49e5..a67b0d833cc 100644
--- a/folly/synchronization/test/SmallLocksBenchmark.cpp
+++ b/folly/synchronization/test/SmallLocksBenchmark.cpp
@@ -426,8 +426,7 @@ struct VirtualBase {
 };
 
 struct VirtualImpl : VirtualBase {
-  void foo() override { /* noop */
-  }
+  void foo() override { /* noop */ }
   ~VirtualImpl() override {}
 };
 
diff --git a/folly/system/ThreadId.cpp b/folly/system/ThreadId.cpp
index fa365a64133..12320cb190e 100644
--- a/folly/system/ThreadId.cpp
+++ b/folly/system/ThreadId.cpp
@@ -62,8 +62,7 @@ namespace {
 
 struct CacheState {
   CacheState() {
-    AtFork::registerHandler(
-        this, [] { return true; }, [] {}, [] { ++epoch; });
+    AtFork::registerHandler(this, [] { return true; }, [] {}, [] { ++epoch; });
   }
   ~CacheState() { AtFork::unregisterHandler(this); }
 
diff --git a/folly/system/test/ThreadNameTest.cpp b/folly/system/test/ThreadNameTest.cpp
index d3624fc2ecd..91ac6b9997f 100644
--- a/folly/system/test/ThreadNameTest.cpp
+++ b/folly/system/test/ThreadNameTest.cpp
@@ -40,7 +40,9 @@ TEST(ThreadName, getCurrentThreadName) {
       EXPECT_EQ(kThreadName.toString(), *getCurrentThreadName());
     }
   });
-  SCOPE_EXIT { th.join(); };
+  SCOPE_EXIT {
+    th.join();
+  };
 }
 
 #if FOLLY_HAVE_PTHREAD
@@ -53,9 +55,13 @@ TEST(ThreadName, setThreadNameOtherPthread) {
     handle_set.post();
     let_thread_end.wait();
   });
-  SCOPE_EXIT { th.join(); };
+  SCOPE_EXIT {
+    th.join();
+  };
   handle_set.wait();
-  SCOPE_EXIT { let_thread_end.post(); };
+  SCOPE_EXIT {
+    let_thread_end.post();
+  };
   EXPECT_EQ(
       expectedSetOtherThreadNameResult, setThreadName(handle, kThreadName));
 }
@@ -64,8 +70,12 @@ TEST(ThreadName, setThreadNameOtherPthread) {
 TEST(ThreadName, setThreadNameOtherId) {
   Baton<> let_thread_end;
   thread th([&] { let_thread_end.wait(); });
-  SCOPE_EXIT { th.join(); };
-  SCOPE_EXIT { let_thread_end.post(); };
+  SCOPE_EXIT {
+    th.join();
+  };
+  SCOPE_EXIT {
+    let_thread_end.post();
+  };
   EXPECT_EQ(
       expectedSetOtherThreadNameResult,
       setThreadName(th.get_id(), kThreadName));
diff --git a/folly/test/AHMIntStressTest.cpp b/folly/test/AHMIntStressTest.cpp
index 4c6fc4c2168..d82eb0529e7 100644
--- a/folly/test/AHMIntStressTest.cpp
+++ b/folly/test/AHMIntStressTest.cpp
@@ -103,7 +103,9 @@ struct MyObjectDirectory {
  */
 TEST(AHMIntStressTest, Test) {
   auto const objs = new MyObjectDirectory();
-  SCOPE_EXIT { delete objs; };
+  SCOPE_EXIT {
+    delete objs;
+  };
 
   std::vector<std::thread> threads;
   for (int threadId = 0; threadId < 64; ++threadId) {
diff --git a/folly/test/AtomicHashArrayTest.cpp b/folly/test/AtomicHashArrayTest.cpp
index 3ba290ed42d..8f787b7bf18 100644
--- a/folly/test/AtomicHashArrayTest.cpp
+++ b/folly/test/AtomicHashArrayTest.cpp
@@ -377,7 +377,9 @@ TEST(Aha, LookupAny) {
   auto arr = AHACstrInt::create(12);
 
   char* f_char = strdup("f");
-  SCOPE_EXIT { free(f_char); };
+  SCOPE_EXIT {
+    free(f_char);
+  };
   arr->insert(std::make_pair(f_char, 42));
 
   EXPECT_EQ(42, arr->find("f")->second);
diff --git a/folly/test/AtomicHashMapTest.cpp b/folly/test/AtomicHashMapTest.cpp
index 9047b3f6e78..498adad95d8 100644
--- a/folly/test/AtomicHashMapTest.cpp
+++ b/folly/test/AtomicHashMapTest.cpp
@@ -304,7 +304,9 @@ TEST(Ahm, counter) {
   const int mult = 10;
   Counters c(numKeys);
   vector<int64_t> keys;
-  FOR_EACH_RANGE (i, 1, numKeys) { keys.push_back(i); }
+  FOR_EACH_RANGE (i, 1, numKeys) {
+    keys.push_back(i);
+  }
   vector<std::thread> threads;
   for (auto key : keys) {
     FOR_EACH_RANGE (i, 0, key * mult) {
diff --git a/folly/test/AtomicUnorderedMapTest.cpp b/folly/test/AtomicUnorderedMapTest.cpp
index ac0a8a0e8af..d7031ba9dda 100644
--- a/folly/test/AtomicUnorderedMapTest.cpp
+++ b/folly/test/AtomicUnorderedMapTest.cpp
@@ -238,7 +238,9 @@ BENCHMARK(lookup_int_int_hit, iters) {
     EXPECT_EQ(iter->second, k + 1);
   }
 
-  BENCHMARK_SUSPEND { ptr.reset(nullptr); }
+  BENCHMARK_SUSPEND {
+    ptr.reset(nullptr);
+  }
 }
 
 struct PairHash {
@@ -302,7 +304,9 @@ void contendedRW(
     thr.join();
   }
 
-  BENCHMARK_SUSPEND { ptr.reset(nullptr); }
+  BENCHMARK_SUSPEND {
+    ptr.reset(nullptr);
+  }
 }
 
 // clang-format off
diff --git a/folly/test/BenchmarkIntegrationTest.cpp b/folly/test/BenchmarkIntegrationTest.cpp
index 049a7cb82f7..b854fc91b18 100644
--- a/folly/test/BenchmarkIntegrationTest.cpp
+++ b/folly/test/BenchmarkIntegrationTest.cpp
@@ -48,7 +48,9 @@ BENCHMARK(bmFun) {
   fun();
 }
 BENCHMARK(bmRepeatedFun, n) {
-  FOR_EACH_RANGE (i, 0, n) { fun(); }
+  FOR_EACH_RANGE (i, 0, n) {
+    fun();
+  }
 }
 BENCHMARK_DRAW_LINE();
 
@@ -251,14 +253,20 @@ BENCHMARK_DRAW_LINE();
 BENCHMARK(baselinevector) {
   vector<int> v;
 
-  BENCHMARK_SUSPEND { v.resize(1000); }
+  BENCHMARK_SUSPEND {
+    v.resize(1000);
+  }
 
-  FOR_EACH_RANGE (i, 0, 100) { v.push_back(42); }
+  FOR_EACH_RANGE (i, 0, 100) {
+    v.push_back(42);
+  }
 }
 
 BENCHMARK_RELATIVE(bmVector) {
   vector<int> v;
-  FOR_EACH_RANGE (i, 0, 100) { v.resize(v.size() + 1, 42); }
+  FOR_EACH_RANGE (i, 0, 100) {
+    v.resize(v.size() + 1, 42);
+  }
 }
 
 BENCHMARK_DRAW_LINE();
@@ -274,7 +282,9 @@ BENCHMARK(noMulti) {
 }
 
 BENCHMARK_MULTI(multiSimple) {
-  FOR_EACH_RANGE (i, 0, 10) { fun(); }
+  FOR_EACH_RANGE (i, 0, 10) {
+    fun();
+  }
   return 10;
 }
 
@@ -296,7 +306,9 @@ BENCHMARK_RELATIVE_MULTI(multiSimpleRelThree) {
 }
 
 BENCHMARK_MULTI(multiIterArgs, iter) {
-  FOR_EACH_RANGE (i, 0, 10 * iter) { fun(); }
+  FOR_EACH_RANGE (i, 0, 10 * iter) {
+    fun();
+  }
   return 10 * iter;
 }
 
diff --git a/folly/test/ConcurrentSkipListBenchmark.cpp b/folly/test/ConcurrentSkipListBenchmark.cpp
index 266e78a0cbf..050bce0ee92 100644
--- a/folly/test/ConcurrentSkipListBenchmark.cpp
+++ b/folly/test/ConcurrentSkipListBenchmark.cpp
@@ -503,7 +503,9 @@ void BM_ContentionCSL(int iters, int size) {
     threads.push_back(
         std::thread(&ConcurrentAccessData::runSkipList, data, i, iters));
   }
-  FOR_EACH (t, threads) { (*t).join(); }
+  FOR_EACH (t, threads) {
+    (*t).join();
+  }
 }
 
 void BM_ContentionStdSet(int iters, int size) {
@@ -516,7 +518,9 @@ void BM_ContentionStdSet(int iters, int size) {
     threads.push_back(
         std::thread(&ConcurrentAccessData::runSet, data, i, iters));
   }
-  FOR_EACH (t, threads) { (*t).join(); }
+  FOR_EACH (t, threads) {
+    (*t).join();
+  }
   susp.rehire();
 }
 
diff --git a/folly/test/ConcurrentSkipListTest.cpp b/folly/test/ConcurrentSkipListTest.cpp
index 411eda1c9ba..00c4c9bd64d 100644
--- a/folly/test/ConcurrentSkipListTest.cpp
+++ b/folly/test/ConcurrentSkipListTest.cpp
@@ -108,7 +108,9 @@ static void randomRemoval(
 
 static void sumAllValues(SkipListAccessor skipList, int64_t* sum) {
   *sum = 0;
-  FOR_EACH (it, skipList) { *sum += *it; }
+  FOR_EACH (it, skipList) {
+    *sum += *it;
+  }
   VLOG(20) << "sum = " << sum;
 }
 
@@ -317,7 +319,9 @@ TEST(ConcurrentSkipList, ConcurrentAdd) {
   }
 
   SetType all;
-  FOR_EACH (s, verifiers) { all.insert(s->begin(), s->end()); }
+  FOR_EACH (s, verifiers) {
+    all.insert(s->begin(), s->end());
+  }
   verifyEqual(skipList, all);
 }
 
@@ -338,10 +342,14 @@ void testConcurrentRemoval(int numThreads, int maxValue) {
     LOG(WARNING) << "Caught " << exceptionStr(e) << ": could only create "
                  << threads.size() << " threads out of " << numThreads;
   }
-  FOR_EACH (t, threads) { (*t).join(); }
+  FOR_EACH (t, threads) {
+    (*t).join();
+  }
 
   SetType all;
-  FOR_EACH (s, verifiers) { all.insert(s->begin(), s->end()); }
+  FOR_EACH (s, verifiers) {
+    all.insert(s->begin(), s->end());
+  }
 
   CHECK_EQ(maxValue, all.size() + skipList.size());
   for (int i = 0; i < maxValue; ++i) {
@@ -396,7 +404,9 @@ static void testConcurrentAccess(
     }
   }
 
-  FOR_EACH (t, threads) { (*t).join(); }
+  FOR_EACH (t, threads) {
+    (*t).join();
+  }
   // just run through it, no need to verify the correctness.
 }
 
diff --git a/folly/test/ConvBenchmark.cpp b/folly/test/ConvBenchmark.cpp
index fd8135a7adb..9495861c109 100644
--- a/folly/test/ConvBenchmark.cpp
+++ b/folly/test/ConvBenchmark.cpp
@@ -319,7 +319,9 @@ void follyAtoiMeasure(unsigned int n, unsigned int digits) {
 void clibAtoiMeasure(unsigned int n, unsigned int digits) {
   auto p = pc1.subpiece(pc1.size() - digits, digits);
   assert(*p.end() == 0);
-  FOR_EACH_RANGE (i, 0, n) { doNotOptimizeAway(atoll(p.begin())); }
+  FOR_EACH_RANGE (i, 0, n) {
+    doNotOptimizeAway(atoll(p.begin()));
+  }
 }
 
 void lexicalCastMeasure(unsigned int n, unsigned int digits) {
@@ -475,7 +477,9 @@ struct StringIdenticalToBM {
   StringIdenticalToBM() {}
   void operator()(unsigned int n, size_t len) const {
     String s;
-    BENCHMARK_SUSPEND { s.append(len, '0'); }
+    BENCHMARK_SUSPEND {
+      s.append(len, '0');
+    }
     FOR_EACH_RANGE (i, 0, n) {
       String result = to<String>(s);
       doNotOptimizeAway(result.size());
@@ -488,7 +492,9 @@ struct StringVariadicToBM {
   StringVariadicToBM() {}
   void operator()(unsigned int n, size_t len) const {
     String s;
-    BENCHMARK_SUSPEND { s.append(len, '0'); }
+    BENCHMARK_SUSPEND {
+      s.append(len, '0');
+    }
     FOR_EACH_RANGE (i, 0, n) {
       String result = to<String>(s, nullptr);
       doNotOptimizeAway(result.size());
diff --git a/folly/test/ExceptionTest.cpp b/folly/test/ExceptionTest.cpp
index 2f2d8f3354c..2917ba847c0 100644
--- a/folly/test/ExceptionTest.cpp
+++ b/folly/test/ExceptionTest.cpp
@@ -75,7 +75,9 @@ TEST(ExceptionTest, Simple) {
   auto exnpath = tmpdir.path() / "ExceptionTest";
   auto fp = fopen(exnpath.string().c_str(), "w+b");
   ASSERT_TRUE(fp != nullptr);
-  SCOPE_EXIT { fclose(fp); };
+  SCOPE_EXIT {
+    fclose(fp);
+  };
 
   EXPECT_NO_THROW(checkFopenError(fp, "hello", " world"));
   errno = ERANGE;
diff --git a/folly/test/ExceptionWrapperTest.cpp b/folly/test/ExceptionWrapperTest.cpp
index 11659ee8f60..9df3607d282 100644
--- a/folly/test/ExceptionWrapperTest.cpp
+++ b/folly/test/ExceptionWrapperTest.cpp
@@ -766,6 +766,5 @@ TEST(ExceptionWrapper, selfSwapTest) {
 
 TEST(ExceptionWrapper, terminateWithTest) {
   auto ew = make_exception_wrapper<int>(42);
-  EXPECT_DEATH(
-      try { ew.terminate_with(); } catch (...){}, "int");
+  EXPECT_DEATH(try { ew.terminate_with(); } catch (...){}, "int");
 }
diff --git a/folly/test/ExpectedCoroutinesTest.cpp b/folly/test/ExpectedCoroutinesTest.cpp
index caad70ab5bf..fcfd1baae1c 100644
--- a/folly/test/ExpectedCoroutinesTest.cpp
+++ b/folly/test/ExpectedCoroutinesTest.cpp
@@ -135,7 +135,9 @@ TEST(Expected, CoroutineException) {
 TEST(Expected, CoroutineCleanedUp) {
   int count_dest = 0;
   auto r = [&]() -> Expected<int, Err> {
-    SCOPE_EXIT { ++count_dest; };
+    SCOPE_EXIT {
+      ++count_dest;
+    };
     auto x = co_await Expected<int, Err>(makeUnexpected(Err::badder()));
     ADD_FAILURE() << "Should not be resuming";
     co_return x;
diff --git a/folly/test/FBStringBenchmark.cpp b/folly/test/FBStringBenchmark.cpp
index 0445bfbe7bd..bcf54c6d4f0 100644
--- a/folly/test/FBStringBenchmark.cpp
+++ b/folly/test/FBStringBenchmark.cpp
@@ -44,14 +44,18 @@ template <class String>
 void randomString(String* toFill, size_t size = 1000) {
   assert(toFill);
   toFill->resize(size);
-  FOR_EACH (i, *toFill) { *i = random('a', 'z'); }
+  FOR_EACH (i, *toFill) {
+    *i = random('a', 'z');
+  }
 }
 
 template <class String>
 void randomBinaryString(String* toFill, size_t size = 1000) {
   assert(toFill);
   toFill->resize(size);
-  FOR_EACH (i, *toFill) { *i = random('0', '1'); }
+  FOR_EACH (i, *toFill) {
+    *i = random('0', '1');
+  }
 }
 
 template <class String, class Integral>
diff --git a/folly/test/FBStringTest.cpp b/folly/test/FBStringTest.cpp
index 3fda5da83be..f82e3672d1f 100644
--- a/folly/test/FBStringTest.cpp
+++ b/folly/test/FBStringTest.cpp
@@ -94,7 +94,9 @@ template <class String>
 void randomString(String* toFill, unsigned int maxSize = 1000) {
   assert(toFill);
   toFill->resize(random(0, maxSize));
-  FOR_EACH (i, *toFill) { *i = random('a', 'z'); }
+  FOR_EACH (i, *toFill) {
+    *i = random('a', 'z');
+  }
 }
 
 template <class String, class Integral>
@@ -220,7 +222,9 @@ void clause11_21_4_2_j(String& test) {
   auto size = random(0, 2000);
   String s(size, '\0');
   EXPECT_EQ(s.size(), size);
-  FOR_EACH_RANGE (i, 0, s.size()) { s[i] = random('a', 'z'); }
+  FOR_EACH_RANGE (i, 0, s.size()) {
+    s[i] = random('a', 'z');
+  }
   test = s;
 }
 template <class String>
@@ -229,7 +233,9 @@ void clause11_21_4_2_k(String& test) {
   auto size = random(0, 2000);
   String s(size, '\0');
   EXPECT_EQ(s.size(), size);
-  FOR_EACH_RANGE (i, 0, s.size()) { s[i] = random('a', 'z'); }
+  FOR_EACH_RANGE (i, 0, s.size()) {
+    s[i] = random('a', 'z');
+  }
   test = std::move(s);
   if (std::is_same<String, fbstring>::value) {
     EXPECT_LE(s.size(), 128);
@@ -334,7 +340,9 @@ void clause11_21_4_6_1(String& test) {
   auto len = test.size();
   test += test1;
   EXPECT_EQ(test.size(), test1.size() + len);
-  FOR_EACH_RANGE (i, 0, test1.size()) { EXPECT_EQ(test[len + i], test1[i]); }
+  FOR_EACH_RANGE (i, 0, test1.size()) {
+    EXPECT_EQ(test[len + i], test1[i]);
+  }
   // aliasing modifiers
   String test2 = test;
   auto dt = test2.data();
@@ -1125,8 +1133,8 @@ TEST(FBString, testAllClauses) {
       rng = RandomT(localSeed);
       f_fbstring(c);
       EXPECT_EQ(r, c) << "Lengths: " << r.size() << " vs. " << c.size()
-                      << "\nReference: '" << r << "'"
-                      << "\nActual:    '" << c.data()[0] << "'";
+                      << "\nReference: '" << r << "'" << "\nActual:    '"
+                      << c.data()[0] << "'";
 #if FOLLY_HAVE_WCHAR_SUPPORT
       rng = RandomT(localSeed);
       f_wfbstring(wc);
diff --git a/folly/test/FBStringTestBenchmarks.cpp.h b/folly/test/FBStringTestBenchmarks.cpp.h
index 85d0e7e74b2..616b731f954 100644
--- a/folly/test/FBStringTestBenchmarks.cpp.h
+++ b/folly/test/FBStringTestBenchmarks.cpp.h
@@ -36,7 +36,9 @@ BENCHMARK_PARAM(BENCHFUN(defaultCtor), 0)
 
 void BENCHFUN(copyCtor)(size_t iters, size_t arg) {
   STRING s;
-  BENCHMARK_SUSPEND { randomString(&s, arg); }
+  BENCHMARK_SUSPEND {
+    randomString(&s, arg);
+  }
   FOR_EACH_RANGE (i, 0, iters) {
     STRING s1 = s;
     doNotOptimizeAway(&s1);
@@ -87,7 +89,9 @@ BENCHMARK_PARAM(BENCHFUN(ctorFromChar), 1048576)
 
 void BENCHFUN(assignmentOp)(size_t iters, size_t arg) {
   STRING s;
-  BENCHMARK_SUSPEND { randomString(&s, arg); }
+  BENCHMARK_SUSPEND {
+    randomString(&s, arg);
+  }
   FOR_EACH_RANGE (i, 0, iters) {
     STRING s1;
     BENCHMARK_SUSPEND {
@@ -184,7 +188,9 @@ expect to get a call for an interview.";
     s1 = "So how do you tackle that writing sample request?";
   }
 
-  FOR_EACH_RANGE (i, 0, iters) { doNotOptimizeAway(s.find(s1)); }
+  FOR_EACH_RANGE (i, 0, iters) {
+    doNotOptimizeAway(s.find(s1));
+  }
 }
 BENCHMARK_PARAM(BENCHFUN(findUnsuccessful), 524288)
 
@@ -207,7 +213,9 @@ BENCHMARK_PARAM(BENCHFUN(equality), 65536)
 
 void BENCHFUN(replace)(size_t iters, size_t arg) {
   STRING s;
-  BENCHMARK_SUSPEND { randomString(&s, arg); }
+  BENCHMARK_SUSPEND {
+    randomString(&s, arg);
+  }
   FOR_EACH_RANGE (i, 0, iters) {
     BenchmarkSuspender susp;
     doNotOptimizeAway(&s);
@@ -226,7 +234,9 @@ BENCHMARK_PARAM(BENCHFUN(replace), 256)
 void BENCHFUN(push_back)(size_t iters, size_t arg) {
   FOR_EACH_RANGE (i, 0, iters) {
     STRING s;
-    FOR_EACH_RANGE (j, 0, arg) { s += ' '; }
+    FOR_EACH_RANGE (j, 0, arg) {
+      s += ' ';
+    }
   }
 }
 BENCHMARK_PARAM(BENCHFUN(push_back), 1)
@@ -237,7 +247,9 @@ BENCHMARK_PARAM(BENCHFUN(push_back), 1024)
 void BENCHFUN(short_append)(size_t iters, size_t arg) {
   FOR_EACH_RANGE (i, 0, iters) {
     STRING s;
-    FOR_EACH_RANGE (j, 0, arg) { s += "012"; }
+    FOR_EACH_RANGE (j, 0, arg) {
+      s += "012";
+    }
   }
 }
 BENCHMARK_PARAM(BENCHFUN(short_append), 23)
diff --git a/folly/test/FBVectorBenchmarks.cpp.h b/folly/test/FBVectorBenchmarks.cpp.h
index 1814c24e48d..9d6c746e0a0 100644
--- a/folly/test/FBVectorBenchmarks.cpp.h
+++ b/folly/test/FBVectorBenchmarks.cpp.h
@@ -68,7 +68,9 @@ void BENCHFUN(insertFront)(int iters, int initialSize) {
   auto const obj = randomObject<VECTOR::value_type>();
   VECTOR v(initialSize, obj);
   braces.dismissing([&]() {
-    FOR_EACH_RANGE (i, 0, iters) { v.insert(v.begin(), obj); }
+    FOR_EACH_RANGE (i, 0, iters) {
+      v.insert(v.begin(), obj);
+    }
   });
 }
 
@@ -84,7 +86,9 @@ void BENCHFUN(pushBack)(int iters, int initialSize) {
   auto const obj = randomObject<VECTOR::value_type>();
   VECTOR v(initialSize, obj);
   braces.dismissing([&]() {
-    FOR_EACH_RANGE (i, 0, iters) { v.push_back(obj); }
+    FOR_EACH_RANGE (i, 0, iters) {
+      v.push_back(obj);
+    }
   });
 }
 
diff --git a/folly/test/FBVectorTest.cpp b/folly/test/FBVectorTest.cpp
index 032dbd452bb..dba5acfd334 100644
--- a/folly/test/FBVectorTest.cpp
+++ b/folly/test/FBVectorTest.cpp
@@ -45,14 +45,18 @@ using FBStringFBVector = fbvector<fbstring>;
 TEST(fbvector, clause233613Ambiguity) {
   fbvector<int> v(10, 20);
   EXPECT_EQ(v.size(), 10);
-  FOR_EACH (i, v) { EXPECT_EQ(*i, 20); }
+  FOR_EACH (i, v) {
+    EXPECT_EQ(*i, 20);
+  }
 }
 
 TEST(fbvector, clause2336111Ambiguity) {
   fbvector<int> v;
   v.assign(10, 20);
   EXPECT_EQ(v.size(), 10);
-  FOR_EACH (i, v) { EXPECT_EQ(*i, 20); }
+  FOR_EACH (i, v) {
+    EXPECT_EQ(*i, 20);
+  }
 }
 
 TEST(fbvector, clause233626) {
diff --git a/folly/test/FBVectorTests.cpp.h b/folly/test/FBVectorTests.cpp.h
index 99d4922d671..f2b06c4e2e9 100644
--- a/folly/test/FBVectorTests.cpp.h
+++ b/folly/test/FBVectorTests.cpp.h
@@ -31,7 +31,9 @@ TESTFUN(clause_23_3_6_1_3) {
   auto const n = random(0U, 10000U);
   VECTOR v(n);
   EXPECT_EQ(v.size(), n);
-  FOR_EACH (i, v) { EXPECT_EQ(*i, VECTOR::value_type()); }
+  FOR_EACH (i, v) {
+    EXPECT_EQ(*i, VECTOR::value_type());
+  }
 }
 
 TESTFUN(clause_23_3_6_1_9) {
@@ -85,7 +87,9 @@ TESTFUN(clause_23_3_6_1_12) {
   auto const obj = randomObject<VECTOR::value_type>();
   v.assign(n, obj);
   EXPECT_EQ(v.size(), n);
-  FOR_EACH (i, v) { EXPECT_EQ(*i, obj); }
+  FOR_EACH (i, v) {
+    EXPECT_EQ(*i, obj);
+  }
 }
 
 TESTFUN(clause_23_3_6_2_1) {
@@ -104,16 +108,24 @@ TESTFUN(clause_23_3_6_2_7) {
   v1.swap(v2);
   EXPECT_EQ(v1.size(), n2);
   EXPECT_EQ(v2.size(), n1);
-  FOR_EACH (i, v1) { EXPECT_EQ(*i, obj2); }
-  FOR_EACH (i, v2) { EXPECT_EQ(*i, obj1); }
+  FOR_EACH (i, v1) {
+    EXPECT_EQ(*i, obj2);
+  }
+  FOR_EACH (i, v2) {
+    EXPECT_EQ(*i, obj1);
+  }
 }
 
 TESTFUN(clause_23_3_6_2_9) {
   VECTOR v;
   auto const n1 = random(0U, 10000U);
   v.resize(n1);
-  FOR_EACH (i, v) { EXPECT_EQ(*i, VECTOR::value_type()); }
-  FOR_EACH (i, v) { EXPECT_EQ(*i, VECTOR::value_type()); }
+  FOR_EACH (i, v) {
+    EXPECT_EQ(*i, VECTOR::value_type());
+  }
+  FOR_EACH (i, v) {
+    EXPECT_EQ(*i, VECTOR::value_type());
+  }
 }
 
 TESTFUN(clause_23_3_6_2_11) {
@@ -121,12 +133,16 @@ TESTFUN(clause_23_3_6_2_11) {
   auto const n1 = random(0U, 10000U);
   auto const obj1 = randomObject<VECTOR::value_type>();
   v.resize(n1, obj1);
-  FOR_EACH (i, v) { EXPECT_EQ(*i, obj1); }
+  FOR_EACH (i, v) {
+    EXPECT_EQ(*i, obj1);
+  }
   auto const n2 = random(0U, 10000U);
   auto const obj2 = randomObject<VECTOR::value_type>();
   v.resize(n2, obj2);
   if (n1 < n2) {
-    FOR_EACH_RANGE (i, n1, n2) { EXPECT_EQ(v[i], obj2); }
+    FOR_EACH_RANGE (i, n1, n2) {
+      EXPECT_EQ(v[i], obj2);
+    }
   }
 }
 
@@ -172,8 +188,12 @@ TESTFUN(clause_23_3_6_4_1_a) {
   EXPECT_EQ(v.size(), w.size() + 1);
   EXPECT_EQ(r - v.begin(), n2);
   EXPECT_EQ(*r, obj2);
-  FOR_EACH_RANGE (i, 0, r - v.begin()) { EXPECT_EQ(v[i], w[i]); }
-  FOR_EACH_RANGE (i, r - v.begin() + 1, v.size()) { EXPECT_EQ(v[i], w[i - 1]); }
+  FOR_EACH_RANGE (i, 0, r - v.begin()) {
+    EXPECT_EQ(v[i], w[i]);
+  }
+  FOR_EACH_RANGE (i, r - v.begin() + 1, v.size()) {
+    EXPECT_EQ(v[i], w[i - 1]);
+  }
 }
 
 TESTFUN(clause_23_3_6_4_1_c) {
@@ -194,7 +214,9 @@ TESTFUN(clause_23_3_6_4_1_c) {
 
   EXPECT_EQ(v.size(), w.size() + n3);
   EXPECT_EQ(r - v.begin(), n2);
-  FOR_EACH_RANGE (i, 0, r - v.begin()) { EXPECT_EQ(v[i], w[i]); }
+  FOR_EACH_RANGE (i, 0, r - v.begin()) {
+    EXPECT_EQ(v[i], w[i]);
+  }
   FOR_EACH_RANGE (i, r - v.begin(), r - v.begin() + n3) {
     EXPECT_EQ(v[i], obj2);
   }
@@ -218,7 +240,9 @@ TESTFUN(clause_23_3_6_4_1_d) {
   EXPECT_EQ(v.back(), obj2);
   EXPECT_EQ(v.size(), w.size() + 1);
 
-  FOR_EACH_RANGE (i, 0, w.size()) { EXPECT_EQ(v[i], w[i]); }
+  FOR_EACH_RANGE (i, 0, w.size()) {
+    EXPECT_EQ(v[i], w[i]);
+  }
 }
 
 TESTFUN(clause_23_3_6_4_3) {
@@ -235,9 +259,13 @@ TESTFUN(clause_23_3_6_4_3) {
   auto it = v.erase(v.begin() + n2);
   EXPECT_EQ(v.size() + 1, w.size());
 
-  FOR_EACH_RANGE (i, 0, it - v.begin()) { EXPECT_EQ(v[i], w[i]); }
+  FOR_EACH_RANGE (i, 0, it - v.begin()) {
+    EXPECT_EQ(v[i], w[i]);
+  }
 
-  FOR_EACH_RANGE (i, it - v.begin(), v.size()) { EXPECT_EQ(v[i], w[i + 1]); }
+  FOR_EACH_RANGE (i, it - v.begin(), v.size()) {
+    EXPECT_EQ(v[i], w[i + 1]);
+  }
 }
 
 TESTFUN(clause_23_3_6_4_4) {
@@ -255,7 +283,9 @@ TESTFUN(clause_23_3_6_4_4) {
   auto it = v.erase(v.begin() + n2, v.begin() + n3);
   EXPECT_EQ(v.size() + (n3 - n2), w.size());
 
-  FOR_EACH_RANGE (i, 0, it - v.begin()) { EXPECT_EQ(v[i], w[i]); }
+  FOR_EACH_RANGE (i, 0, it - v.begin()) {
+    EXPECT_EQ(v[i], w[i]);
+  }
 
   FOR_EACH_RANGE (i, it - v.begin(), v.size()) {
     EXPECT_EQ(v[i], w[i + (n3 - n2)]);
diff --git a/folly/test/FunctionTest.cpp b/folly/test/FunctionTest.cpp
index dd742c2bcac..d27a9b8cc7c 100644
--- a/folly/test/FunctionTest.cpp
+++ b/folly/test/FunctionTest.cpp
@@ -864,7 +864,7 @@ TEST(Function, ParameterCopyMoveCount) {
   EXPECT_LE(cmt.copyCount(), 0);
 
   // pass by rvalue reference
-  Function<size_t(CopyMoveTracker &&)> uf4 = [](CopyMoveTracker&& c) {
+  Function<size_t(CopyMoveTracker&&)> uf4 = [](CopyMoveTracker&& c) {
     return c.moveCount();
   };
 
diff --git a/folly/test/OptionalCoroutinesTest.cpp b/folly/test/OptionalCoroutinesTest.cpp
index 2fc083be1a1..c0a318abaa0 100644
--- a/folly/test/OptionalCoroutinesTest.cpp
+++ b/folly/test/OptionalCoroutinesTest.cpp
@@ -87,7 +87,9 @@ TEST(Optional, CoroutineException) {
 TEST(Optional, CoroutineCleanedUp) {
   int count_dest = 0;
   auto r = [&]() -> Optional<int> {
-    SCOPE_EXIT { ++count_dest; };
+    SCOPE_EXIT {
+      ++count_dest;
+    };
     auto x = co_await folly::Optional<int>();
     ADD_FAILURE() << "Should not be resuming";
     co_return x;
diff --git a/folly/test/RandomBenchmark.cpp b/folly/test/RandomBenchmark.cpp
index 35a583cb2ee..e5bd0af6fa6 100644
--- a/folly/test/RandomBenchmark.cpp
+++ b/folly/test/RandomBenchmark.cpp
@@ -37,7 +37,9 @@ BENCHMARK(minstdrand, n) {
 
   braces.dismiss();
 
-  FOR_EACH_RANGE (i, 0, n) { doNotOptimizeAway(rng()); }
+  FOR_EACH_RANGE (i, 0, n) {
+    doNotOptimizeAway(rng());
+  }
 }
 
 BENCHMARK(mt19937, n) {
@@ -47,7 +49,9 @@ BENCHMARK(mt19937, n) {
 
   braces.dismiss();
 
-  FOR_EACH_RANGE (i, 0, n) { doNotOptimizeAway(rng()); }
+  FOR_EACH_RANGE (i, 0, n) {
+    doNotOptimizeAway(rng());
+  }
 }
 
 #if FOLLY_HAVE_EXTRANDOM_SFMT19937
@@ -58,7 +62,9 @@ BENCHMARK(sfmt19937, n) {
 
   braces.dismiss();
 
-  FOR_EACH_RANGE (i, 0, n) { doNotOptimizeAway(rng()); }
+  FOR_EACH_RANGE (i, 0, n) {
+    doNotOptimizeAway(rng());
+  }
 }
 #endif
 
@@ -69,7 +75,9 @@ BENCHMARK(threadprng, n) {
 
   braces.dismiss();
 
-  FOR_EACH_RANGE (i, 0, n) { doNotOptimizeAway(tprng()); }
+  FOR_EACH_RANGE (i, 0, n) {
+    doNotOptimizeAway(tprng());
+  }
 }
 
 BENCHMARK(RandomDouble) {
diff --git a/folly/test/ScopeGuardTest.cpp b/folly/test/ScopeGuardTest.cpp
index 67ce0740e13..6d9096cae3f 100644
--- a/folly/test/ScopeGuardTest.cpp
+++ b/folly/test/ScopeGuardTest.cpp
@@ -34,64 +34,88 @@ struct in_scope {};
 struct in_guard {};
 
 extern "C" FOLLY_KEEP void check_folly_scope_exit_opaque() {
-  SCOPE_EXIT { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_EXIT {
+    folly::detail::keep_sink(in_guard{});
+  };
   folly::detail::keep_sink(in_scope{});
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_exit_opaque_noexcept() {
-  SCOPE_EXIT { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_EXIT {
+    folly::detail::keep_sink(in_guard{});
+  };
   folly::detail::keep_sink_nx(in_scope{});
 }
 
 extern "C" FOLLY_KEEP [[noreturn]] void check_folly_scope_exit_visible_throw() {
-  SCOPE_EXIT { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_EXIT {
+    folly::detail::keep_sink(in_guard{});
+  };
   throw 0;
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_exit_visible_throw_cond(bool b) {
-  SCOPE_EXIT { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_EXIT {
+    folly::detail::keep_sink(in_guard{});
+  };
   b ? void(throw 0) : void();
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_success_opaque() {
-  SCOPE_SUCCESS { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_SUCCESS {
+    folly::detail::keep_sink(in_guard{});
+  };
   folly::detail::keep_sink(in_scope{});
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_success_opaque_noexcept() {
-  SCOPE_SUCCESS { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_SUCCESS {
+    folly::detail::keep_sink(in_guard{});
+  };
   folly::detail::keep_sink_nx(in_scope{});
 }
 
 extern "C" FOLLY_KEEP [[noreturn]] void
 check_folly_scope_success_visible_throw() {
-  SCOPE_SUCCESS { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_SUCCESS {
+    folly::detail::keep_sink(in_guard{});
+  };
   throw 0;
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_success_visible_throw_cond(
     bool b) {
-  SCOPE_SUCCESS { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_SUCCESS {
+    folly::detail::keep_sink(in_guard{});
+  };
   b ? void(throw 0) : void();
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_fail_opaque() {
-  SCOPE_FAIL { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_FAIL {
+    folly::detail::keep_sink(in_guard{});
+  };
   folly::detail::keep_sink(in_scope{});
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_fail_opaque_noexcept() {
-  SCOPE_FAIL { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_FAIL {
+    folly::detail::keep_sink(in_guard{});
+  };
   folly::detail::keep_sink_nx(in_scope{});
 }
 
 extern "C" FOLLY_KEEP [[noreturn]] void check_folly_scope_fail_visible_throw() {
-  SCOPE_FAIL { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_FAIL {
+    folly::detail::keep_sink(in_guard{});
+  };
   throw 0;
 }
 
 extern "C" FOLLY_KEEP void check_folly_scope_fail_visible_throw_cond(bool b) {
-  SCOPE_FAIL { folly::detail::keep_sink(in_guard{}); };
+  SCOPE_FAIL {
+    folly::detail::keep_sink(in_guard{});
+  };
   b ? void(throw 0) : void();
 }
 
@@ -312,7 +336,9 @@ TEST(ScopeGuard, TryCatchFinally) {
 TEST(ScopeGuard, TESTScopeExit) {
   int x = 0;
   {
-    SCOPE_EXIT { ++x; };
+    SCOPE_EXIT {
+      ++x;
+    };
     EXPECT_EQ(0, x);
   }
   EXPECT_EQ(1, x);
@@ -326,7 +352,9 @@ class Foo {
       auto e = std::current_exception();
       int test = 0;
       {
-        SCOPE_EXIT { ++test; };
+        SCOPE_EXIT {
+          ++test;
+        };
         EXPECT_EQ(0, test);
       }
       EXPECT_EQ(1, test);
@@ -349,8 +377,12 @@ void testScopeFailAndScopeSuccess(ErrorBehavior error, bool expectFail) {
   bool scopeSuccessExecuted = false;
 
   try {
-    SCOPE_FAIL { scopeFailExecuted = true; };
-    SCOPE_SUCCESS { scopeSuccessExecuted = true; };
+    SCOPE_FAIL {
+      scopeFailExecuted = true;
+    };
+    SCOPE_SUCCESS {
+      scopeSuccessExecuted = true;
+    };
 
     try {
       if (error == ErrorBehavior::HANDLED_ERROR) {
@@ -373,7 +405,9 @@ TEST(ScopeGuard, TESTScopeFailExceptionPtr) {
   bool failExecuted = false;
 
   try {
-    SCOPE_FAIL { failExecuted = true; };
+    SCOPE_FAIL {
+      failExecuted = true;
+    };
 
     std::exception_ptr ep;
     try {
@@ -398,7 +432,9 @@ TEST(ScopeGuard, TESTScopeFailAndScopeSuccess) {
 
 TEST(ScopeGuard, TESTScopeSuccessThrow) {
   auto lambda = []() {
-    SCOPE_SUCCESS { throw std::runtime_error("ehm"); };
+    SCOPE_SUCCESS {
+      throw std::runtime_error("ehm");
+    };
   };
   EXPECT_THROW(lambda(), std::runtime_error);
 }
diff --git a/folly/test/StringBenchmark.cpp b/folly/test/StringBenchmark.cpp
index e496da48bdc..389771c3931 100644
--- a/folly/test/StringBenchmark.cpp
+++ b/folly/test/StringBenchmark.cpp
@@ -62,7 +62,9 @@ BENCHMARK(folly_toLowerAscii, iters) {
 const size_t kAppendBufSize = 300000;
 void stringPrintfOutputSize(int iters, int param) {
   string buffer;
-  BENCHMARK_SUSPEND { buffer.resize(param, 'x'); }
+  BENCHMARK_SUSPEND {
+    buffer.resize(param, 'x');
+  }
 
   for (int64_t i = 0; i < iters; ++i) {
     string s = stringPrintf("msg: %d, %d, %s", 10, 20, buffer.c_str());
@@ -84,7 +86,9 @@ BENCHMARK_PARAM(stringPrintfOutputSize, 1024)
 BENCHMARK(stringPrintfAppendfBenchmark, iters) {
   for (size_t i = 0; i < iters; ++i) {
     string s;
-    BENCHMARK_SUSPEND { s.reserve(kAppendBufSize); }
+    BENCHMARK_SUSPEND {
+      s.reserve(kAppendBufSize);
+    }
     for (size_t j = 0; j < kAppendBufSize; ++j) {
       stringAppendf(&s, "%d", 1);
     }
@@ -97,7 +101,9 @@ BENCHMARK(stringPrintfAppendfBenchmark, iters) {
 // Intended for comparison with stringPrintf.
 void fmtOutputSize(int iters, int param) {
   string buffer;
-  BENCHMARK_SUSPEND { buffer.resize(param, 'x'); }
+  BENCHMARK_SUSPEND {
+    buffer.resize(param, 'x');
+  }
 
   for (int64_t i = 0; i < iters; ++i) {
     string s = fmt::format("msg: {}, {}, {}", 10, 20, buffer);
@@ -132,7 +138,9 @@ BENCHMARK(fmtAppendfBenchmark, iters) {
 // Intended for comparison with stringPrintf and fmt.
 void follyFmtOutputSize(int iters, int param) {
   string buffer;
-  BENCHMARK_SUSPEND { buffer.resize(param, 'x'); }
+  BENCHMARK_SUSPEND {
+    buffer.resize(param, 'x');
+  }
 
   for (int64_t i = 0; i < iters; ++i) {
     string s = sformat("msg: {}, {}, {}", 10, 20, buffer);
diff --git a/folly/test/StringTest.cpp b/folly/test/StringTest.cpp
index bcbdcdabecd..5753b1834eb 100644
--- a/folly/test/StringTest.cpp
+++ b/folly/test/StringTest.cpp
@@ -78,10 +78,14 @@ TEST(StringPrintf, Appending) {
 void vprintfCheck(const char* expected, const char* fmt, ...) {
   va_list apOrig;
   va_start(apOrig, fmt);
-  SCOPE_EXIT { va_end(apOrig); };
+  SCOPE_EXIT {
+    va_end(apOrig);
+  };
   va_list ap;
   va_copy(ap, apOrig);
-  SCOPE_EXIT { va_end(ap); };
+  SCOPE_EXIT {
+    va_end(ap);
+  };
 
   // Check both APIs for calling stringVPrintf()
   EXPECT_EQ(expected, stringVPrintf(fmt, ap));
@@ -105,7 +109,9 @@ void vprintfCheck(const char* expected, const char* fmt, ...) {
 void vprintfError(const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
-  SCOPE_EXIT { va_end(ap); };
+  SCOPE_EXIT {
+    va_end(ap);
+  };
 
 #ifdef HAVE_VSNPRINTF_ERRORS
   // OSX's sprintf family does not return a negative number on a bad format
diff --git a/folly/test/SubprocessTest.cpp b/folly/test/SubprocessTest.cpp
index a1d9b85947c..6bc1a03d2ee 100644
--- a/folly/test/SubprocessTest.cpp
+++ b/folly/test/SubprocessTest.cpp
@@ -231,9 +231,7 @@ TEST(
 
 TEST(SubprocessTest, FatalOnDestroy) {
   EXPECT_DEATH(
-      []() {
-        Subprocess proc(std::vector<std::string>{"/bin/sleep", "10"});
-      }(),
+      []() { Subprocess proc(std::vector<std::string>{"/bin/sleep", "10"}); }(),
       "Subprocess destroyed without reaping child");
 }
 
diff --git a/folly/test/SynchronizedTest.cpp b/folly/test/SynchronizedTest.cpp
index 04ca66e19cb..f79ccd55385 100644
--- a/folly/test/SynchronizedTest.cpp
+++ b/folly/test/SynchronizedTest.cpp
@@ -680,8 +680,7 @@ void testTryLock(Func func) {
     folly::Synchronized<int, TryLockable<kLockable>> synchronized{
         std::piecewise_construct,
         std::make_tuple(),
-        std::make_tuple(
-            true, [&] { ++locked; }, [&] { ++unlocked; })};
+        std::make_tuple(true, [&] { ++locked; }, [&] { ++unlocked; })};
 
     {
       auto lock = func(synchronized);
@@ -697,8 +696,7 @@ void testTryLock(Func func) {
     folly::Synchronized<int, TryLockable<kLockable>> synchronized{
         std::piecewise_construct,
         std::make_tuple(),
-        std::make_tuple(
-            false, [&] { ++locked; }, [&] { ++unlocked; })};
+        std::make_tuple(false, [&] { ++locked; }, [&] { ++unlocked; })};
 
     {
       auto lock = func(synchronized);
diff --git a/folly/test/SynchronizedTestLib-inl.h b/folly/test/SynchronizedTestLib-inl.h
index cb1ff7447ea..f0c3981e324 100644
--- a/folly/test/SynchronizedTestLib-inl.h
+++ b/folly/test/SynchronizedTestLib-inl.h
@@ -449,9 +449,13 @@ template <class Mutex>
     EXPECT_EQ(1000, obj2.contextualLock()->size());
   }
 
-  SYNCHRONIZED_CONST(obj) { EXPECT_EQ(1001, obj.size()); }
+  SYNCHRONIZED_CONST(obj) {
+    EXPECT_EQ(1001, obj.size());
+  }
 
-  SYNCHRONIZED(lockedObj, *&obj) { lockedObj.front() = 2; }
+  SYNCHRONIZED(lockedObj, *&obj) {
+    lockedObj.front() = 2;
+  }
 
   EXPECT_EQ(1001, obj.contextualLock()->size());
   EXPECT_EQ(10, obj.contextualLock()->back());
diff --git a/folly/test/ThreadCachedIntTest.cpp b/folly/test/ThreadCachedIntTest.cpp
index 4d23ee8b41d..2cacabbf535 100644
--- a/folly/test/ThreadCachedIntTest.cpp
+++ b/folly/test/ThreadCachedIntTest.cpp
@@ -226,7 +226,9 @@ TEST(ThreadCachedInt, MultiThreadedCached) {
     std::vector<std::thread> threads;
     for (int i = 0; i < FLAGS_numThreads; ++i) {
       threads.push_back(std::thread([&] {
-        FOR_EACH_RANGE (k, 0, numPerThread) { ++TCInt64; }
+        FOR_EACH_RANGE (k, 0, numPerThread) {
+          ++TCInt64;
+        }
         std::atomic_fetch_add(&threadsDone, 1);
         while (run.load()) {
           usleep(100);
diff --git a/folly/test/TraitsTest.cpp b/folly/test/TraitsTest.cpp
index 9f43520d326..a1f3a34b4a4 100644
--- a/folly/test/TraitsTest.cpp
+++ b/folly/test/TraitsTest.cpp
@@ -288,11 +288,15 @@ void testIsRelocatable(Args&&... args) {
   char vcpy[sizeof(T)];
 
   T* src = new (vsrc) T(std::forward<Args>(args)...);
-  SCOPE_EXIT { src->~T(); };
+  SCOPE_EXIT {
+    src->~T();
+  };
   std::memcpy(vcpy, vsrc, sizeof(T));
   T deep(*src);
   T* dst = new (vdst) T(std::move(*src));
-  SCOPE_EXIT { dst->~T(); };
+  SCOPE_EXIT {
+    dst->~T();
+  };
 
   EXPECT_EQ(deep, *dst);
 #pragma GCC diagnostic push
diff --git a/folly/test/UtilityTest.cpp b/folly/test/UtilityTest.cpp
index c84653003ac..fdce25a4e0f 100644
--- a/folly/test/UtilityTest.cpp
+++ b/folly/test/UtilityTest.cpp
@@ -352,7 +352,7 @@ static constexpr bool is_conv_v = std::is_convertible_v<S, D>;
 
 template <typename S, typename D>
 static constexpr bool is_nx_conv_v = //
-    is_conv_v<S, D>&& std::is_nothrow_constructible_v<D, S>;
+    is_conv_v<S, D> && std::is_nothrow_constructible_v<D, S>;
 
 static_assert(is_conv_v<of<int, 0, 0, 0>&, int>);
 static_assert(!is_conv_v<of<int, 0, 0, 0> const&, int>);
diff --git a/folly/test/stl_tests/StlVectorTest.cpp b/folly/test/stl_tests/StlVectorTest.cpp
index 3635582ae7f..3a078b78b55 100644
--- a/folly/test/stl_tests/StlVectorTest.cpp
+++ b/folly/test/stl_tests/StlVectorTest.cpp
@@ -162,7 +162,7 @@ the cascade of errors will be enormous. They are, therefore, tested first.
 #define VECTOR_ folly::fbvector
 #endif
 
-//#define USING_STD_VECTOR
+// #define USING_STD_VECTOR
 
 #include <climits>
 #include <cstddef>
@@ -392,7 +392,7 @@ int Ticker::TicksLeft = -1;
 
 template <Flags f>
 struct DataTicker : Ticker {
-  DataTicker() noexcept(f& DC_NOEXCEPT) {
+  DataTicker() noexcept(f & DC_NOEXCEPT) {
     if (!(f & DC_NOEXCEPT)) {
       Tick("Data()");
     }
@@ -1174,8 +1174,7 @@ struct PrettyType<Alloc<T>> {
   }                                                                   \
   if (ticks >= 0 && Ticker::CountTicks > ticks && !ticks_thrown)      \
     FAIL() << "CountTicks = " << Ticker::CountTicks << " > " << ticks \
-           << " = ticks"                                              \
-           << ", but no tick error was observed";                     \
+           << " = ticks" << ", but no tick error was observed";       \
   VERIFICATION
 #define CLOSER_ticks }