From: Phil Willoughby <philwill@fb.com>
Date: Tue, 7 Feb 2017 08:44:56 +0000 (-0800)
Subject: Run clang-format over Format*.h
X-Git-Tag: v2017.03.06.00~52
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=9773e441c61fd246829aeb8f371968fc7866aa8c;p=folly.git

Run clang-format over Format*.h

Summary:
Changes are planned, this will make it easier for the new code to look good
without making the older code look weird.

Reviewed By: yfeldblum

Differential Revision: D4514839

fbshipit-source-id: 43f8cd7d85901e1915cc434a0f4b5fd6bce1ec7a
---

diff --git a/folly/Format-inl.h b/folly/Format-inl.h
index deb8bdaa..1b998dec 100644
--- a/folly/Format-inl.h
+++ b/folly/Format-inl.h
@@ -60,8 +60,8 @@ const size_t kMaxBinaryLength = 8 * sizeof(uintmax_t);
  * [buf+begin, buf+bufLen).
  */
 template <class Uint>
-size_t uintToHex(char* buffer, size_t bufLen, Uint v,
-                 const char (&repr)[256][2]) {
+size_t
+uintToHex(char* buffer, size_t bufLen, Uint v, const char (&repr)[256][2]) {
   // 'v >>= 7, v >>= 1' is no more than a work around to get rid of shift size
   // warning when Uint = uint8_t (it's false as v >= 256 implies sizeof(v) > 1).
   for (; !less_than<unsigned, 256>(v); v >>= 7, v >>= 1) {
@@ -151,26 +151,28 @@ size_t uintToBinary(char* buffer, size_t bufLen, Uint v) {
   return bufLen;
 }
 
-}  // namespace detail
+} // namespace detail
 
 template <class Derived, bool containerMode, class... Args>
-BaseFormatter<Derived, containerMode, Args...>::BaseFormatter(StringPiece str,
-                                                              Args&&... args)
+BaseFormatter<Derived, containerMode, Args...>::BaseFormatter(
+    StringPiece str,
+    Args&&... args)
     : str_(str),
       values_(FormatValue<typename std::decay<Args>::type>(
           std::forward<Args>(args))...) {
-  static_assert(!containerMode || sizeof...(Args) == 1,
-                "Exactly one argument required in container mode");
+  static_assert(
+      !containerMode || sizeof...(Args) == 1,
+      "Exactly one argument required in container mode");
 }
 
 template <class Derived, bool containerMode, class... Args>
 template <class Output>
-void BaseFormatter<Derived, containerMode, Args...>::operator()(Output& out)
-    const {
+void BaseFormatter<Derived, containerMode, Args...>::operator()(
+    Output& out) const {
   // Copy raw string (without format specifiers) to output;
   // not as simple as we'd like, as we still need to translate "}}" to "}"
   // and throw if we see any lone "}"
-  auto outputString = [&out] (StringPiece s) {
+  auto outputString = [&out](StringPiece s) {
     auto p = s.begin();
     auto end = s.end();
     while (p != end) {
@@ -225,10 +227,11 @@ void BaseFormatter<Derived, containerMode, Args...>::operator()(Output& out)
     p = q + 1;
 
     int argIndex = 0;
-    auto piece = arg.splitKey<true>();  // empty key component is okay
-    if (containerMode) {  // static
-      arg.enforce(arg.width != FormatArg::kDynamicWidth,
-                  "dynamic field width not supported in vformat()");
+    auto piece = arg.splitKey<true>(); // empty key component is okay
+    if (containerMode) { // static
+      arg.enforce(
+          arg.width != FormatArg::kDynamicWidth,
+          "dynamic field width not supported in vformat()");
       if (piece.empty()) {
         arg.setNextIntKey(nextArg++);
         hasDefaultArgIndex = true;
@@ -239,8 +242,9 @@ void BaseFormatter<Derived, containerMode, Args...>::operator()(Output& out)
     } else {
       if (piece.empty()) {
         if (arg.width == FormatArg::kDynamicWidth) {
-          arg.enforce(arg.widthIndex == FormatArg::kNoIndex,
-                      "cannot provide width arg index without value arg index");
+          arg.enforce(
+              arg.widthIndex == FormatArg::kNoIndex,
+              "cannot provide width arg index without value arg index");
           int sizeArg = nextArg++;
           arg.width = getSizeArg(size_t(sizeArg), arg);
         }
@@ -249,8 +253,9 @@ void BaseFormatter<Derived, containerMode, Args...>::operator()(Output& out)
         hasDefaultArgIndex = true;
       } else {
         if (arg.width == FormatArg::kDynamicWidth) {
-          arg.enforce(arg.widthIndex != FormatArg::kNoIndex,
-                      "cannot provide value arg index without width arg index");
+          arg.enforce(
+              arg.widthIndex != FormatArg::kNoIndex,
+              "cannot provide value arg index without width arg index");
           arg.width = getSizeArg(size_t(arg.widthIndex), arg);
         }
 
@@ -274,9 +279,10 @@ void BaseFormatter<Derived, containerMode, Args...>::operator()(Output& out)
 }
 
 template <class Derived, bool containerMode, class... Args>
-void writeTo(FILE* fp,
-             const BaseFormatter<Derived, containerMode, Args...>& formatter) {
-  auto writer = [fp] (StringPiece sp) {
+void writeTo(
+    FILE* fp,
+    const BaseFormatter<Derived, containerMode, Args...>& formatter) {
+  auto writer = [fp](StringPiece sp) {
     size_t n = fwrite(sp.data(), 1, sp.size(), fp);
     if (n < sp.size()) {
       throwSystemError("Formatter writeTo", "fwrite failed");
@@ -309,7 +315,7 @@ void formatString(StringPiece val, FormatArg& arg, FormatCallback& cb) {
   char padBuf[padBufSize];
 
   // Output padding, no more than padBufSize at once
-  auto pad = [&padBuf, &cb, padBufSize] (int chars) {
+  auto pad = [&padBuf, &cb, padBufSize](int chars) {
     while (chars) {
       int n = std::min(chars, padBufSize);
       cb(StringPiece(padBuf, size_t(n)));
@@ -321,25 +327,25 @@ void formatString(StringPiece val, FormatArg& arg, FormatCallback& cb) {
   if (arg.width != FormatArg::kDefaultWidth &&
       val.size() < static_cast<size_t>(arg.width)) {
     char fill = arg.fill == FormatArg::kDefaultFill ? ' ' : arg.fill;
-    int padChars = static_cast<int> (arg.width - val.size());
+    int padChars = static_cast<int>(arg.width - val.size());
     memset(padBuf, fill, size_t(std::min(padBufSize, padChars)));
 
     switch (arg.align) {
-    case FormatArg::Align::DEFAULT:
-    case FormatArg::Align::LEFT:
-      padRemaining = padChars;
-      break;
-    case FormatArg::Align::CENTER:
-      pad(padChars / 2);
-      padRemaining = padChars - padChars / 2;
-      break;
-    case FormatArg::Align::RIGHT:
-    case FormatArg::Align::PAD_AFTER_SIGN:
-      pad(padChars);
-      break;
-    default:
-      abort();
-      break;
+      case FormatArg::Align::DEFAULT:
+      case FormatArg::Align::LEFT:
+        padRemaining = padChars;
+        break;
+      case FormatArg::Align::CENTER:
+        pad(padChars / 2);
+        padRemaining = padChars - padChars / 2;
+        break;
+      case FormatArg::Align::RIGHT:
+      case FormatArg::Align::PAD_AFTER_SIGN:
+        pad(padChars);
+        break;
+      default:
+        abort();
+        break;
     }
   }
 
@@ -351,8 +357,11 @@ void formatString(StringPiece val, FormatArg& arg, FormatCallback& cb) {
 }
 
 template <class FormatCallback>
-void formatNumber(StringPiece val, int prefixLen, FormatArg& arg,
-                  FormatCallback& cb) {
+void formatNumber(
+    StringPiece val,
+    int prefixLen,
+    FormatArg& arg,
+    FormatCallback& cb) {
   // precision means something different for numbers
   arg.precision = FormatArg::kDefaultPrecision;
   if (arg.align == FormatArg::Align::DEFAULT) {
@@ -366,10 +375,11 @@ void formatNumber(StringPiece val, int prefixLen, FormatArg& arg,
   format_value::formatString(val, arg, cb);
 }
 
-template <class FormatCallback,
-          class Derived,
-          bool containerMode,
-          class... Args>
+template <
+    class FormatCallback,
+    class Derived,
+    bool containerMode,
+    class... Args>
 void formatFormatter(
     const BaseFormatter<Derived, containerMode, Args...>& formatter,
     FormatArg& arg,
@@ -378,13 +388,14 @@ void formatFormatter(
       arg.precision == FormatArg::kDefaultPrecision) {
     // nothing to do
     formatter(cb);
-  } else if (arg.align != FormatArg::Align::LEFT &&
-             arg.align != FormatArg::Align::DEFAULT) {
+  } else if (
+      arg.align != FormatArg::Align::LEFT &&
+      arg.align != FormatArg::Align::DEFAULT) {
     // We can only avoid creating a temporary string if we align left,
     // as we'd need to know the size beforehand otherwise
     format_value::formatString(formatter.fbstr(), arg, cb);
   } else {
-    auto fn = [&arg, &cb] (StringPiece sp) mutable {
+    auto fn = [&arg, &cb](StringPiece sp) mutable {
       int sz = static_cast<int>(sp.size());
       if (arg.precision != FormatArg::kDefaultPrecision) {
         sz = std::min(arg.precision, sz);
@@ -406,19 +417,18 @@ void formatFormatter(
   }
 }
 
-}  // namespace format_value
+} // namespace format_value
 
 // Definitions for default FormatValue classes
 
 // Integral types (except bool)
 template <class T>
 class FormatValue<
-  T, typename std::enable_if<
-    std::is_integral<T>::value &&
-    !std::is_same<T, bool>::value>::type>
-  {
+    T,
+    typename std::enable_if<
+        std::is_integral<T>::value && !std::is_same<T, bool>::value>::type> {
  public:
-  explicit FormatValue(T val) : val_(val) { }
+  explicit FormatValue(T val) : val_(val) {}
 
   T getValue() const {
     return val_;
@@ -449,23 +459,24 @@ class FormatValue<
       } else {
         uval = static_cast<UT>(val_);
         switch (arg.sign) {
-        case FormatArg::Sign::PLUS_OR_MINUS:
-          sign = '+';
-          break;
-        case FormatArg::Sign::SPACE_OR_MINUS:
-          sign = ' ';
-          break;
-        default:
-          sign = '\0';
-          break;
+          case FormatArg::Sign::PLUS_OR_MINUS:
+            sign = '+';
+            break;
+          case FormatArg::Sign::SPACE_OR_MINUS:
+            sign = ' ';
+            break;
+          default:
+            sign = '\0';
+            break;
         }
       }
     } else {
       uval = static_cast<UT>(val_);
       sign = '\0';
 
-      arg.enforce(arg.sign == FormatArg::Sign::DEFAULT,
-                  "sign specifications not allowed for unsigned values");
+      arg.enforce(
+          arg.sign == FormatArg::Sign::DEFAULT,
+          "sign specifications not allowed for unsigned values");
     }
 
     // max of:
@@ -482,109 +493,131 @@ class FormatValue<
 
     int prefixLen = 0;
     switch (presentation) {
-    case 'n': {
-      arg.enforce(!arg.basePrefix,
-                  "base prefix not allowed with '", presentation,
-                  "' specifier");
-
-      arg.enforce(!arg.thousandsSeparator,
-                  "cannot use ',' with the '", presentation,
-                  "' specifier");
-
-      valBufBegin = valBuf + 3;  // room for sign and base prefix
+      case 'n': {
+        arg.enforce(
+            !arg.basePrefix,
+            "base prefix not allowed with '",
+            presentation,
+            "' specifier");
+
+        arg.enforce(
+            !arg.thousandsSeparator,
+            "cannot use ',' with the '",
+            presentation,
+            "' specifier");
+
+        valBufBegin = valBuf + 3; // room for sign and base prefix
 #if defined(__ANDROID__)
-      int len = snprintf(valBufBegin, (valBuf + valBufSize) - valBufBegin,
-                         "%" PRIuMAX, static_cast<uintmax_t>(uval));
+        int len = snprintf(
+            valBufBegin,
+            (valBuf + valBufSize) - valBufBegin,
+            "%" PRIuMAX,
+            static_cast<uintmax_t>(uval));
 #else
-      int len = snprintf(
-          valBufBegin,
-          size_t((valBuf + valBufSize) - valBufBegin),
-          "%ju",
-          static_cast<uintmax_t>(uval));
+        int len = snprintf(
+            valBufBegin,
+            size_t((valBuf + valBufSize) - valBufBegin),
+            "%ju",
+            static_cast<uintmax_t>(uval));
 #endif
-      // valBufSize should always be big enough, so this should never
-      // happen.
-      assert(len < valBuf + valBufSize - valBufBegin);
-      valBufEnd = valBufBegin + len;
-      break;
-    }
-    case 'd':
-      arg.enforce(!arg.basePrefix,
-                  "base prefix not allowed with '", presentation,
-                  "' specifier");
-      valBufBegin = valBuf + 3;  // room for sign and base prefix
-
-      // Use uintToBuffer, faster than sprintf
-      valBufEnd = valBufBegin + uint64ToBufferUnsafe(uval, valBufBegin);
-      if (arg.thousandsSeparator) {
-        detail::insertThousandsGroupingUnsafe(valBufBegin, &valBufEnd);
-      }
-      break;
-    case 'c':
-      arg.enforce(!arg.basePrefix,
-                  "base prefix not allowed with '", presentation,
-                  "' specifier");
-      arg.enforce(!arg.thousandsSeparator,
-                  "thousands separator (',') not allowed with '",
-                  presentation, "' specifier");
-      valBufBegin = valBuf + 3;
-      *valBufBegin = static_cast<char>(uval);
-      valBufEnd = valBufBegin + 1;
-      break;
-    case 'o':
-    case 'O':
-      arg.enforce(!arg.thousandsSeparator,
-                  "thousands separator (',') not allowed with '",
-                  presentation, "' specifier");
-      valBufEnd = valBuf + valBufSize - 1;
-      valBufBegin = valBuf + detail::uintToOctal(valBuf, valBufSize - 1, uval);
-      if (arg.basePrefix) {
-        *--valBufBegin = '0';
-        prefixLen = 1;
-      }
-      break;
-    case 'x':
-      arg.enforce(!arg.thousandsSeparator,
-                  "thousands separator (',') not allowed with '",
-                  presentation, "' specifier");
-      valBufEnd = valBuf + valBufSize - 1;
-      valBufBegin = valBuf + detail::uintToHexLower(valBuf, valBufSize - 1,
-                                                    uval);
-      if (arg.basePrefix) {
-        *--valBufBegin = 'x';
-        *--valBufBegin = '0';
-        prefixLen = 2;
-      }
-      break;
-    case 'X':
-      arg.enforce(!arg.thousandsSeparator,
-                  "thousands separator (',') not allowed with '",
-                  presentation, "' specifier");
-      valBufEnd = valBuf + valBufSize - 1;
-      valBufBegin = valBuf + detail::uintToHexUpper(valBuf, valBufSize - 1,
-                                                    uval);
-      if (arg.basePrefix) {
-        *--valBufBegin = 'X';
-        *--valBufBegin = '0';
-        prefixLen = 2;
-      }
-      break;
-    case 'b':
-    case 'B':
-      arg.enforce(!arg.thousandsSeparator,
-                  "thousands separator (',') not allowed with '",
-                  presentation, "' specifier");
-      valBufEnd = valBuf + valBufSize - 1;
-      valBufBegin = valBuf + detail::uintToBinary(valBuf, valBufSize - 1,
-                                                  uval);
-      if (arg.basePrefix) {
-        *--valBufBegin = presentation;  // 0b or 0B
-        *--valBufBegin = '0';
-        prefixLen = 2;
+        // valBufSize should always be big enough, so this should never
+        // happen.
+        assert(len < valBuf + valBufSize - valBufBegin);
+        valBufEnd = valBufBegin + len;
+        break;
       }
-      break;
-    default:
-      arg.error("invalid specifier '", presentation, "'");
+      case 'd':
+        arg.enforce(
+            !arg.basePrefix,
+            "base prefix not allowed with '",
+            presentation,
+            "' specifier");
+        valBufBegin = valBuf + 3; // room for sign and base prefix
+
+        // Use uintToBuffer, faster than sprintf
+        valBufEnd = valBufBegin + uint64ToBufferUnsafe(uval, valBufBegin);
+        if (arg.thousandsSeparator) {
+          detail::insertThousandsGroupingUnsafe(valBufBegin, &valBufEnd);
+        }
+        break;
+      case 'c':
+        arg.enforce(
+            !arg.basePrefix,
+            "base prefix not allowed with '",
+            presentation,
+            "' specifier");
+        arg.enforce(
+            !arg.thousandsSeparator,
+            "thousands separator (',') not allowed with '",
+            presentation,
+            "' specifier");
+        valBufBegin = valBuf + 3;
+        *valBufBegin = static_cast<char>(uval);
+        valBufEnd = valBufBegin + 1;
+        break;
+      case 'o':
+      case 'O':
+        arg.enforce(
+            !arg.thousandsSeparator,
+            "thousands separator (',') not allowed with '",
+            presentation,
+            "' specifier");
+        valBufEnd = valBuf + valBufSize - 1;
+        valBufBegin =
+            valBuf + detail::uintToOctal(valBuf, valBufSize - 1, uval);
+        if (arg.basePrefix) {
+          *--valBufBegin = '0';
+          prefixLen = 1;
+        }
+        break;
+      case 'x':
+        arg.enforce(
+            !arg.thousandsSeparator,
+            "thousands separator (',') not allowed with '",
+            presentation,
+            "' specifier");
+        valBufEnd = valBuf + valBufSize - 1;
+        valBufBegin =
+            valBuf + detail::uintToHexLower(valBuf, valBufSize - 1, uval);
+        if (arg.basePrefix) {
+          *--valBufBegin = 'x';
+          *--valBufBegin = '0';
+          prefixLen = 2;
+        }
+        break;
+      case 'X':
+        arg.enforce(
+            !arg.thousandsSeparator,
+            "thousands separator (',') not allowed with '",
+            presentation,
+            "' specifier");
+        valBufEnd = valBuf + valBufSize - 1;
+        valBufBegin =
+            valBuf + detail::uintToHexUpper(valBuf, valBufSize - 1, uval);
+        if (arg.basePrefix) {
+          *--valBufBegin = 'X';
+          *--valBufBegin = '0';
+          prefixLen = 2;
+        }
+        break;
+      case 'b':
+      case 'B':
+        arg.enforce(
+            !arg.thousandsSeparator,
+            "thousands separator (',') not allowed with '",
+            presentation,
+            "' specifier");
+        valBufEnd = valBuf + valBufSize - 1;
+        valBufBegin =
+            valBuf + detail::uintToBinary(valBuf, valBufSize - 1, uval);
+        if (arg.basePrefix) {
+          *--valBufBegin = presentation; // 0b or 0B
+          *--valBufBegin = '0';
+          prefixLen = 2;
+        }
+        break;
+      default:
+        arg.error("invalid specifier '", presentation, "'");
     }
 
     if (sign) {
@@ -592,8 +625,8 @@ class FormatValue<
       ++prefixLen;
     }
 
-    format_value::formatNumber(StringPiece(valBufBegin, valBufEnd), prefixLen,
-                               arg, cb);
+    format_value::formatNumber(
+        StringPiece(valBufBegin, valBufEnd), prefixLen, arg, cb);
   }
 
  private:
@@ -604,14 +637,14 @@ class FormatValue<
 template <>
 class FormatValue<bool> {
  public:
-  explicit FormatValue(bool val) : val_(val) { }
+  explicit FormatValue(bool val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     if (arg.presentation == FormatArg::kDefaultPresentation) {
       arg.validate(FormatArg::Type::OTHER);
       format_value::formatString(val_ ? "true" : "false", arg, cb);
-    } else {  // number
+    } else { // number
       FormatValue<int>(val_).format(arg, cb);
     }
   }
@@ -624,7 +657,7 @@ class FormatValue<bool> {
 template <>
 class FormatValue<double> {
  public:
-  explicit FormatValue(double val) : val_(val) { }
+  explicit FormatValue(double val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
@@ -644,7 +677,7 @@ class FormatValue<double> {
 template <>
 class FormatValue<float> {
  public:
-  explicit FormatValue(float val) : val_(val) { }
+  explicit FormatValue(float val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
@@ -658,22 +691,27 @@ class FormatValue<float> {
 // Sring-y types (implicitly convertible to StringPiece, except char*)
 template <class T>
 class FormatValue<
-  T, typename std::enable_if<
-      (!std::is_pointer<T>::value ||
-       !std::is_same<char, typename std::decay<
-          typename std::remove_pointer<T>::type>::type>::value) &&
-      std::is_convertible<T, StringPiece>::value>::type>
-  {
+    T,
+    typename std::enable_if<
+        (!std::is_pointer<T>::value ||
+         !std::is_same<
+             char,
+             typename std::decay<typename std::remove_pointer<T>::type>::type>::
+             value) &&
+        std::is_convertible<T, StringPiece>::value>::type> {
  public:
-  explicit FormatValue(StringPiece val) : val_(val) { }
+  explicit FormatValue(StringPiece val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     if (arg.keyEmpty()) {
       arg.validate(FormatArg::Type::OTHER);
-      arg.enforce(arg.presentation == FormatArg::kDefaultPresentation ||
-                  arg.presentation == 's',
-                  "invalid specifier '", arg.presentation, "'");
+      arg.enforce(
+          arg.presentation == FormatArg::kDefaultPresentation ||
+              arg.presentation == 's',
+          "invalid specifier '",
+          arg.presentation,
+          "'");
       format_value::formatString(val_, arg, cb);
     } else {
       FormatValue<char>(val_.at(size_t(arg.splitIntKey()))).format(arg, cb);
@@ -688,13 +726,16 @@ class FormatValue<
 template <>
 class FormatValue<std::nullptr_t> {
  public:
-  explicit FormatValue(std::nullptr_t) { }
+  explicit FormatValue(std::nullptr_t) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     arg.validate(FormatArg::Type::OTHER);
-    arg.enforce(arg.presentation == FormatArg::kDefaultPresentation,
-                "invalid specifier '", arg.presentation, "'");
+    arg.enforce(
+        arg.presentation == FormatArg::kDefaultPresentation,
+        "invalid specifier '",
+        arg.presentation,
+        "'");
     format_value::formatString("(null)", arg, cb);
   }
 };
@@ -702,12 +743,11 @@ class FormatValue<std::nullptr_t> {
 // Partial specialization of FormatValue for char*
 template <class T>
 class FormatValue<
-  T*,
-  typename std::enable_if<
-      std::is_same<char, typename std::decay<T>::type>::value>::type>
-  {
+    T*,
+    typename std::enable_if<
+        std::is_same<char, typename std::decay<T>::type>::value>::type> {
  public:
-  explicit FormatValue(T* val) : val_(val) { }
+  explicit FormatValue(T* val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
@@ -718,8 +758,8 @@ class FormatValue<
         FormatValue<StringPiece>(val_).format(arg, cb);
       }
     } else {
-      FormatValue<typename std::decay<T>::type>(
-          val_[arg.splitIntKey()]).format(arg, cb);
+      FormatValue<typename std::decay<T>::type>(val_[arg.splitIntKey()])
+          .format(arg, cb);
     }
   }
 
@@ -730,12 +770,11 @@ class FormatValue<
 // Partial specialization of FormatValue for void*
 template <class T>
 class FormatValue<
-  T*,
-  typename std::enable_if<
-      std::is_same<void, typename std::decay<T>::type>::value>::type>
-  {
+    T*,
+    typename std::enable_if<
+        std::is_same<void, typename std::decay<T>::type>::value>::type> {
  public:
-  explicit FormatValue(T* val) : val_(val) { }
+  explicit FormatValue(T* val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
@@ -744,15 +783,18 @@ class FormatValue<
     } else {
       // Print as a pointer, in hex.
       arg.validate(FormatArg::Type::OTHER);
-      arg.enforce(arg.presentation == FormatArg::kDefaultPresentation,
-                  "invalid specifier '", arg.presentation, "'");
+      arg.enforce(
+          arg.presentation == FormatArg::kDefaultPresentation,
+          "invalid specifier '",
+          arg.presentation,
+          "'");
       arg.basePrefix = true;
       arg.presentation = 'x';
       if (arg.align == FormatArg::Align::DEFAULT) {
         arg.align = FormatArg::Align::LEFT;
       }
-      FormatValue<uintptr_t>(
-          reinterpret_cast<uintptr_t>(val_)).doFormat(arg, cb);
+      FormatValue<uintptr_t>(reinterpret_cast<uintptr_t>(val_))
+          .doFormat(arg, cb);
     }
   }
 
@@ -764,19 +806,17 @@ template <class T, class = void>
 class TryFormatValue {
  public:
   template <class FormatCallback>
-  static void formatOrFail(T& /* value */,
-                           FormatArg& arg,
-                           FormatCallback& /* cb */) {
+  static void
+  formatOrFail(T& /* value */, FormatArg& arg, FormatCallback& /* cb */) {
     arg.error("No formatter available for this type");
   }
 };
 
 template <class T>
 class TryFormatValue<
-  T,
-  typename std::enable_if<
-      0 < sizeof(FormatValue<typename std::decay<T>::type>)>::type>
-  {
+    T,
+    typename std::enable_if<
+        0 < sizeof(FormatValue<typename std::decay<T>::type>)>::type> {
  public:
   template <class FormatCallback>
   static void formatOrFail(T& value, FormatArg& arg, FormatCallback& cb) {
@@ -787,13 +827,12 @@ class TryFormatValue<
 // Partial specialization of FormatValue for other pointers
 template <class T>
 class FormatValue<
-  T*,
-  typename std::enable_if<
-      !std::is_same<char, typename std::decay<T>::type>::value &&
-      !std::is_same<void, typename std::decay<T>::type>::value>::type>
-  {
+    T*,
+    typename std::enable_if<
+        !std::is_same<char, typename std::decay<T>::type>::value &&
+        !std::is_same<void, typename std::decay<T>::type>::value>::type> {
  public:
-  explicit FormatValue(T* val) : val_(val) { }
+  explicit FormatValue(T* val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
@@ -803,6 +842,7 @@ class FormatValue<
       TryFormatValue<T>::formatOrFail(val_[arg.splitIntKey()], arg, cb);
     }
   }
+
  private:
   T* val_;
 };
@@ -812,53 +852,46 @@ namespace detail {
 // std::array
 template <class T, size_t N>
 struct IndexableTraits<std::array<T, N>>
-  : public IndexableTraitsSeq<std::array<T, N>> {
-};
+    : public IndexableTraitsSeq<std::array<T, N>> {};
 
 // std::vector
 template <class T, class A>
 struct IndexableTraits<std::vector<T, A>>
-  : public IndexableTraitsSeq<std::vector<T, A>> {
-};
+    : public IndexableTraitsSeq<std::vector<T, A>> {};
 
 // std::deque
 template <class T, class A>
 struct IndexableTraits<std::deque<T, A>>
-  : public IndexableTraitsSeq<std::deque<T, A>> {
-};
+    : public IndexableTraitsSeq<std::deque<T, A>> {};
 
 // std::map with integral keys
 template <class K, class T, class C, class A>
 struct IndexableTraits<
-  std::map<K, T, C, A>,
-  typename std::enable_if<std::is_integral<K>::value>::type>
-  : public IndexableTraitsAssoc<std::map<K, T, C, A>> {
-};
+    std::map<K, T, C, A>,
+    typename std::enable_if<std::is_integral<K>::value>::type>
+    : public IndexableTraitsAssoc<std::map<K, T, C, A>> {};
 
 // std::unordered_map with integral keys
 template <class K, class T, class H, class E, class A>
 struct IndexableTraits<
-  std::unordered_map<K, T, H, E, A>,
-  typename std::enable_if<std::is_integral<K>::value>::type>
-  : public IndexableTraitsAssoc<std::unordered_map<K, T, H, E, A>> {
-};
+    std::unordered_map<K, T, H, E, A>,
+    typename std::enable_if<std::is_integral<K>::value>::type>
+    : public IndexableTraitsAssoc<std::unordered_map<K, T, H, E, A>> {};
 
-}  // namespace detail
+} // namespace detail
 
 // Partial specialization of FormatValue for integer-indexable containers
 template <class T>
-class FormatValue<
-  T,
-  typename detail::IndexableTraits<T>::enabled> {
+class FormatValue<T, typename detail::IndexableTraits<T>::enabled> {
  public:
-  explicit FormatValue(const T& val) : val_(val) { }
+  explicit FormatValue(const T& val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     FormatValue<typename std::decay<
-      typename detail::IndexableTraits<T>::value_type>::type>(
-        detail::IndexableTraits<T>::at(
-            val_, arg.splitIntKey())).format(arg, cb);
+        typename detail::IndexableTraits<T>::value_type>::type>(
+        detail::IndexableTraits<T>::at(val_, arg.splitIntKey()))
+        .format(arg, cb);
   }
 
  private:
@@ -867,20 +900,19 @@ class FormatValue<
 
 template <class Container, class Value>
 class FormatValue<
-  detail::DefaultValueWrapper<Container, Value>,
-  typename detail::IndexableTraits<Container>::enabled> {
+    detail::DefaultValueWrapper<Container, Value>,
+    typename detail::IndexableTraits<Container>::enabled> {
  public:
   explicit FormatValue(const detail::DefaultValueWrapper<Container, Value>& val)
-    : val_(val) { }
+      : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     FormatValue<typename std::decay<
-      typename detail::IndexableTraits<Container>::value_type>::type>(
-          detail::IndexableTraits<Container>::at(
-              val_.container,
-              arg.splitIntKey(),
-              val_.defaultValue)).format(arg, cb);
+        typename detail::IndexableTraits<Container>::value_type>::type>(
+        detail::IndexableTraits<Container>::at(
+            val_.container, arg.splitIntKey(), val_.defaultValue))
+        .format(arg, cb);
   }
 
  private:
@@ -891,7 +923,8 @@ namespace detail {
 
 // Define enabled, key_type, convert from StringPiece to the key types
 // that we support
-template <class T> struct KeyFromStringPiece;
+template <class T>
+struct KeyFromStringPiece;
 
 // std::string
 template <>
@@ -922,14 +955,15 @@ struct KeyFromStringPiece<StringPiece> : public FormatTraitsBase {
 };
 
 // Base class for associative types keyed by strings
-template <class T> struct KeyableTraitsAssoc : public FormatTraitsBase {
+template <class T>
+struct KeyableTraitsAssoc : public FormatTraitsBase {
   typedef typename T::key_type key_type;
   typedef typename T::value_type::second_type value_type;
   static const value_type& at(const T& map, StringPiece key) {
     return map.at(KeyFromStringPiece<key_type>::convert(key));
   }
-  static const value_type& at(const T& map, StringPiece key,
-                              const value_type& dflt) {
+  static const value_type&
+  at(const T& map, StringPiece key, const value_type& dflt) {
     auto pos = map.find(KeyFromStringPiece<key_type>::convert(key));
     return pos != map.end() ? pos->second : dflt;
   }
@@ -937,40 +971,37 @@ template <class T> struct KeyableTraitsAssoc : public FormatTraitsBase {
 
 // Define enabled, key_type, value_type, at() for supported string-keyed
 // types
-template <class T, class Enabled=void> struct KeyableTraits;
+template <class T, class Enabled = void>
+struct KeyableTraits;
 
 // std::map with string key
 template <class K, class T, class C, class A>
 struct KeyableTraits<
-  std::map<K, T, C, A>,
-  typename KeyFromStringPiece<K>::enabled>
-  : public KeyableTraitsAssoc<std::map<K, T, C, A>> {
-};
+    std::map<K, T, C, A>,
+    typename KeyFromStringPiece<K>::enabled>
+    : public KeyableTraitsAssoc<std::map<K, T, C, A>> {};
 
 // std::unordered_map with string key
 template <class K, class T, class H, class E, class A>
 struct KeyableTraits<
-  std::unordered_map<K, T, H, E, A>,
-  typename KeyFromStringPiece<K>::enabled>
-  : public KeyableTraitsAssoc<std::unordered_map<K, T, H, E, A>> {
-};
+    std::unordered_map<K, T, H, E, A>,
+    typename KeyFromStringPiece<K>::enabled>
+    : public KeyableTraitsAssoc<std::unordered_map<K, T, H, E, A>> {};
 
-}  // namespace detail
+} // namespace detail
 
 // Partial specialization of FormatValue for string-keyed containers
 template <class T>
-class FormatValue<
-  T,
-  typename detail::KeyableTraits<T>::enabled> {
+class FormatValue<T, typename detail::KeyableTraits<T>::enabled> {
  public:
-  explicit FormatValue(const T& val) : val_(val) { }
+  explicit FormatValue(const T& val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     FormatValue<typename std::decay<
-      typename detail::KeyableTraits<T>::value_type>::type>(
-        detail::KeyableTraits<T>::at(
-            val_, arg.splitKey())).format(arg, cb);
+        typename detail::KeyableTraits<T>::value_type>::type>(
+        detail::KeyableTraits<T>::at(val_, arg.splitKey()))
+        .format(arg, cb);
   }
 
  private:
@@ -979,20 +1010,19 @@ class FormatValue<
 
 template <class Container, class Value>
 class FormatValue<
-  detail::DefaultValueWrapper<Container, Value>,
-  typename detail::KeyableTraits<Container>::enabled> {
+    detail::DefaultValueWrapper<Container, Value>,
+    typename detail::KeyableTraits<Container>::enabled> {
  public:
   explicit FormatValue(const detail::DefaultValueWrapper<Container, Value>& val)
-    : val_(val) { }
+      : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     FormatValue<typename std::decay<
-      typename detail::KeyableTraits<Container>::value_type>::type>(
-          detail::KeyableTraits<Container>::at(
-              val_.container,
-              arg.splitKey(),
-              val_.defaultValue)).format(arg, cb);
+        typename detail::KeyableTraits<Container>::value_type>::type>(
+        detail::KeyableTraits<Container>::at(
+            val_.container, arg.splitKey(), val_.defaultValue))
+        .format(arg, cb);
   }
 
  private:
@@ -1003,20 +1033,20 @@ class FormatValue<
 template <class A, class B>
 class FormatValue<std::pair<A, B>> {
  public:
-  explicit FormatValue(const std::pair<A, B>& val) : val_(val) { }
+  explicit FormatValue(const std::pair<A, B>& val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     int key = arg.splitIntKey();
     switch (key) {
-    case 0:
-      FormatValue<typename std::decay<A>::type>(val_.first).format(arg, cb);
-      break;
-    case 1:
-      FormatValue<typename std::decay<B>::type>(val_.second).format(arg, cb);
-      break;
-    default:
-      arg.error("invalid index for pair");
+      case 0:
+        FormatValue<typename std::decay<A>::type>(val_.first).format(arg, cb);
+        break;
+      case 1:
+        FormatValue<typename std::decay<B>::type>(val_.second).format(arg, cb);
+        break;
+      default:
+        arg.error("invalid index for pair");
     }
   }
 
@@ -1028,8 +1058,9 @@ class FormatValue<std::pair<A, B>> {
 template <class... Args>
 class FormatValue<std::tuple<Args...>> {
   typedef std::tuple<Args...> Tuple;
+
  public:
-  explicit FormatValue(const Tuple& val) : val_(val) { }
+  explicit FormatValue(const Tuple& val) : val_(val) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
@@ -1042,8 +1073,8 @@ class FormatValue<std::tuple<Args...>> {
   static constexpr size_t valueCount = std::tuple_size<Tuple>::value;
 
   template <size_t K, class Callback>
-  typename std::enable_if<K == valueCount>::type doFormatFrom(
-      size_t i, FormatArg& arg, Callback& /* cb */) const {
+  typename std::enable_if<K == valueCount>::type
+  doFormatFrom(size_t i, FormatArg& arg, Callback& /* cb */) const {
     arg.enforce("tuple index out of range, max=", i);
   }
 
@@ -1052,10 +1083,10 @@ class FormatValue<std::tuple<Args...>> {
   doFormatFrom(size_t i, FormatArg& arg, Callback& cb) const {
     if (i == K) {
       FormatValue<typename std::decay<
-        typename std::tuple_element<K, Tuple>::type>::type>(
-          std::get<K>(val_)).format(arg, cb);
+          typename std::tuple_element<K, Tuple>::type>::type>(std::get<K>(val_))
+          .format(arg, cb);
     } else {
-      doFormatFrom<K+1>(i, arg, cb);
+      doFormatFrom<K + 1>(i, arg, cb);
     }
   }
 
@@ -1068,20 +1099,21 @@ class FormatValue<std::tuple<Args...>> {
 };
 
 // Partial specialization of FormatValue for nested Formatters
-template <bool containerMode, class... Args,
-          template <bool, class...> class F>
-class FormatValue<F<containerMode, Args...>,
-                  typename std::enable_if<detail::IsFormatter<
-                      F<containerMode, Args...>>::value>::type> {
+template <bool containerMode, class... Args, template <bool, class...> class F>
+class FormatValue<
+    F<containerMode, Args...>,
+    typename std::enable_if<
+        detail::IsFormatter<F<containerMode, Args...>>::value>::type> {
   typedef typename F<containerMode, Args...>::BaseType FormatterValue;
 
  public:
-  explicit FormatValue(const FormatterValue& f) : f_(f) { }
+  explicit FormatValue(const FormatterValue& f) : f_(f) {}
 
   template <class FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     format_value::formatFormatter(f_, arg, cb);
   }
+
  private:
   const FormatterValue& f_;
 };
@@ -1092,10 +1124,11 @@ class FormatValue<F<containerMode, Args...>,
  */
 template <class Tgt, class Derived, bool containerMode, class... Args>
 typename std::enable_if<IsSomeString<Tgt>::value>::type toAppend(
-    const BaseFormatter<Derived, containerMode, Args...>& value, Tgt* result) {
+    const BaseFormatter<Derived, containerMode, Args...>& value,
+    Tgt* result) {
   value.appendTo(*result);
 }
 
-}  // namespace folly
+} // namespace folly
 
 #pragma GCC diagnostic pop
diff --git a/folly/Format.h b/folly/Format.h
index 7601ae52..f87d90a9 100644
--- a/folly/Format.h
+++ b/folly/Format.h
@@ -22,10 +22,10 @@
 #include <type_traits>
 
 #include <folly/Conv.h>
+#include <folly/FormatArg.h>
 #include <folly/Range.h>
-#include <folly/Traits.h>
 #include <folly/String.h>
-#include <folly/FormatArg.h>
+#include <folly/Traits.h>
 
 // Ignore shadowing warnings within this file, so includers can use -Wshadow.
 #pragma GCC diagnostic push
@@ -34,12 +34,14 @@
 namespace folly {
 
 // forward declarations
-template <bool containerMode, class... Args> class Formatter;
+template <bool containerMode, class... Args>
+class Formatter;
 template <class... Args>
 Formatter<false, Args...> format(StringPiece fmt, Args&&... args);
 template <class C>
 Formatter<true, C> vformat(StringPiece fmt, C&& container);
-template <class T, class Enable=void> class FormatValue;
+template <class T, class Enable = void>
+class FormatValue;
 
 // meta-attribute to identify formatters in this sea of template weirdness
 namespace detail {
@@ -71,9 +73,9 @@ class BaseFormatter {
    * Append to a string.
    */
   template <class Str>
-  typename std::enable_if<IsSomeString<Str>::value>::type
-  appendTo(Str& str) const {
-    auto appender = [&str] (StringPiece s) { str.append(s.data(), s.size()); };
+  typename std::enable_if<IsSomeString<Str>::value>::type appendTo(
+      Str& str) const {
+    auto appender = [&str](StringPiece s) { str.append(s.data(), s.size()); };
     (*this)(appender);
   }
 
@@ -102,8 +104,8 @@ class BaseFormatter {
   typedef BaseFormatter BaseType;
 
  private:
-  typedef std::tuple<FormatValue<
-      typename std::decay<Args>::type>...> ValueTuple;
+  typedef std::tuple<FormatValue<typename std::decay<Args>::type>...>
+      ValueTuple;
   static constexpr size_t valueCount = std::tuple_size<ValueTuple>::value;
 
   template <size_t K, class Callback>
@@ -118,7 +120,7 @@ class BaseFormatter {
     if (i == K) {
       static_cast<const Derived*>(this)->template doFormatArg<K>(arg, cb);
     } else {
-      doFormatFrom<K+1>(i, arg, cb);
+      doFormatFrom<K + 1>(i, arg, cb);
     }
   }
 
@@ -128,32 +130,36 @@ class BaseFormatter {
   }
 
   template <size_t K>
-  typename std::enable_if<K == valueCount, int>::type
-  getSizeArgFrom(size_t i, const FormatArg& arg) const {
+  typename std::enable_if<K == valueCount, int>::type getSizeArgFrom(
+      size_t i,
+      const FormatArg& arg) const {
     arg.error("argument index out of range, max=", i);
   }
 
   template <class T>
-  typename std::enable_if<std::is_integral<T>::value &&
-                          !std::is_same<T, bool>::value, int>::type
+  typename std::enable_if<
+      std::is_integral<T>::value && !std::is_same<T, bool>::value,
+      int>::type
   getValue(const FormatValue<T>& format, const FormatArg&) const {
     return static_cast<int>(format.getValue());
   }
 
   template <class T>
-  typename std::enable_if<!std::is_integral<T>::value ||
-                          std::is_same<T, bool>::value, int>::type
+  typename std::enable_if<
+      !std::is_integral<T>::value || std::is_same<T, bool>::value,
+      int>::type
   getValue(const FormatValue<T>&, const FormatArg& arg) const {
     arg.error("dynamic field width argument must be integral");
   }
 
   template <size_t K>
-  typename std::enable_if<K < valueCount, int>::type
-  getSizeArgFrom(size_t i, const FormatArg& arg) const {
+      typename std::enable_if <
+      K<valueCount, int>::type getSizeArgFrom(size_t i, const FormatArg& arg)
+          const {
     if (i == K) {
       return getValue(std::get<K>(values_), arg);
     }
-    return getSizeArgFrom<K+1>(i, arg);
+    return getSizeArgFrom<K + 1>(i, arg);
   }
 
   int getSizeArg(size_t i, const FormatArg& arg) const {
@@ -181,23 +187,26 @@ class BaseFormatter {
 };
 
 template <bool containerMode, class... Args>
-class Formatter : public BaseFormatter<Formatter<containerMode, Args...>,
-                                       containerMode,
-                                       Args...> {
+class Formatter : public BaseFormatter<
+                      Formatter<containerMode, Args...>,
+                      containerMode,
+                      Args...> {
  private:
   explicit Formatter(StringPiece& str, Args&&... args)
-      : BaseFormatter<Formatter<containerMode, Args...>,
-                      containerMode,
-                      Args...>(str, std::forward<Args>(args)...) {}
+      : BaseFormatter<
+            Formatter<containerMode, Args...>,
+            containerMode,
+            Args...>(str, std::forward<Args>(args)...) {}
 
   template <size_t K, class Callback>
   void doFormatArg(FormatArg& arg, Callback& cb) const {
     std::get<K>(this->values_).format(arg, cb);
   }
 
-  friend class BaseFormatter<Formatter<containerMode, Args...>,
-                             containerMode,
-                             Args...>;
+  friend class BaseFormatter<
+      Formatter<containerMode, Args...>,
+      containerMode,
+      Args...>;
 
   template <class... A>
   friend Formatter<false, A...> format(StringPiece fmt, A&&... arg);
@@ -208,9 +217,10 @@ class Formatter : public BaseFormatter<Formatter<containerMode, Args...>,
 /**
  * Formatter objects can be written to streams.
  */
-template<bool containerMode, class... Args>
-std::ostream& operator<<(std::ostream& out,
-                         const Formatter<containerMode, Args...>& formatter) {
+template <bool containerMode, class... Args>
+std::ostream& operator<<(
+    std::ostream& out,
+    const Formatter<containerMode, Args...>& formatter) {
   auto writer = [&out](StringPiece sp) {
     out.write(sp.data(), std::streamsize(sp.size()));
   };
@@ -222,8 +232,9 @@ std::ostream& operator<<(std::ostream& out,
  * Formatter objects can be written to stdio FILEs.
  */
 template <class Derived, bool containerMode, class... Args>
-void writeTo(FILE* fp,
-             const BaseFormatter<Derived, containerMode, Args...>& formatter);
+void writeTo(
+    FILE* fp,
+    const BaseFormatter<Derived, containerMode, Args...>& formatter);
 
 /**
  * Create a formatter object.
@@ -234,8 +245,7 @@ void writeTo(FILE* fp,
  */
 template <class... Args>
 Formatter<false, Args...> format(StringPiece fmt, Args&&... args) {
-  return Formatter<false, Args...>(
-      fmt, std::forward<Args>(args)...);
+  return Formatter<false, Args...>(fmt, std::forward<Args>(args)...);
 }
 
 /**
@@ -262,8 +272,7 @@ inline std::string sformat(StringPiece fmt, Args&&... args) {
  */
 template <class Container>
 Formatter<true, Container> vformat(StringPiece fmt, Container&& container) {
-  return Formatter<true, Container>(
-      fmt, std::forward<Container>(container));
+  return Formatter<true, Container>(fmt, std::forward<Container>(container));
 }
 
 /**
@@ -283,20 +292,20 @@ inline std::string svformat(StringPiece fmt, Container&& container) {
  * format("[no_such_key"], defaulted(map, 42))  -> 42
  */
 namespace detail {
-template <class Container, class Value> struct DefaultValueWrapper {
+template <class Container, class Value>
+struct DefaultValueWrapper {
   DefaultValueWrapper(const Container& container, const Value& defaultValue)
-    : container(container),
-      defaultValue(defaultValue) {
-  }
+      : container(container), defaultValue(defaultValue) {}
 
   const Container& container;
   const Value& defaultValue;
 };
-}  // namespace
+} // namespace
 
 template <class Container, class Value>
-detail::DefaultValueWrapper<Container, Value>
-defaulted(const Container& c, const Value& v) {
+detail::DefaultValueWrapper<Container, Value> defaulted(
+    const Container& c,
+    const Value& v) {
   return detail::DefaultValueWrapper<Container, Value>(c, v);
 }
 
@@ -345,25 +354,28 @@ void formatString(StringPiece val, FormatArg& arg, FormatCallback& cb);
  * field width")
  */
 template <class FormatCallback>
-void formatNumber(StringPiece val, int prefixLen, FormatArg& arg,
-                  FormatCallback& cb);
-
+void formatNumber(
+    StringPiece val,
+    int prefixLen,
+    FormatArg& arg,
+    FormatCallback& cb);
 
 /**
  * Format a Formatter object recursively.  Behaves just like
  * formatString(fmt.str(), arg, cb); but avoids creating a temporary
  * string if possible.
  */
-template <class FormatCallback,
-          class Derived,
-          bool containerMode,
-          class... Args>
+template <
+    class FormatCallback,
+    class Derived,
+    bool containerMode,
+    class... Args>
 void formatFormatter(
     const BaseFormatter<Derived, containerMode, Args...>& formatter,
     FormatArg& arg,
     FormatCallback& cb);
 
-}  // namespace format_value
+} // namespace format_value
 
 /*
  * Specialize folly::FormatValue for your type.
@@ -411,8 +423,9 @@ inline std::string sformatChecked(StringPiece fmt, Args&&... args) {
   return formatChecked(fmt, std::forward<Args>(args)...).str();
 }
 template <class Container>
-Formatter<true, Container> vformatChecked(StringPiece fmt,
-                                          Container&& container) {
+Formatter<true, Container> vformatChecked(
+    StringPiece fmt,
+    Container&& container) {
   return vformat(fmt, std::forward<Container>(container));
 }
 template <class Container>
@@ -430,7 +443,7 @@ vformatChecked(Str* out, StringPiece fmt, Container&& container) {
   vformatChecked(fmt, std::forward<Container>(container)).appendTo(*out);
 }
 
-}  // namespace folly
+} // namespace folly
 
 #include <folly/Format-inl.h>