SERVER-45445 Upgrade third_party/fmt (6.1.1 -> 7.1.3)

2 files changed, 63 insertions, 105 deletions

diff --git a/src/mongo/bson/generator_extended_canonical_2_0_0.h b/src/mongo/bson/generator_extended_canonical_2_0_0.h
index 93166c3083b..cf9ef9c27db 100644
--- a/src/mongo/bson/generator_extended_canonical_2_0_0.h
+++ b/src/mongo/bson/generator_extended_canonical_2_0_0.h
@@ -35,6 +35,7 @@
 #include "mongo/util/str_escape.h"
 
 #include <fmt/compile.h>
+#include <fmt/format.h>
 
 namespace mongo {
 class ExtendedCanonicalV200Generator {
@@ -60,20 +61,17 @@ public:
     }
 
     void writeInt32(fmt::memory_buffer& buffer, int32_t val) const {
-        static const auto& fmtStr = *new auto(fmt::compile<int32_t>(R"({{"$numberInt":"{}"}})"));
-        compiled_format_to(buffer, fmtStr, val);
+        format_to(std::back_inserter(buffer), FMT_COMPILE(R"({{"$numberInt":"{}"}})"), val);
     }
 
     void writeInt64(fmt::memory_buffer& buffer, int64_t val) const {
-        static const auto& fmtStr = *new auto(fmt::compile<int64_t>(R"({{"$numberLong":"{}"}})"));
-        compiled_format_to(buffer, fmtStr, val);
+        format_to(std::back_inserter(buffer), FMT_COMPILE(R"({{"$numberLong":"{}"}})"), val);
     }
 
     void writeDouble(fmt::memory_buffer& buffer, double val) const {
-        static const auto& fmtStr = *new auto(fmt::compile<double>(R"({{"$numberDouble":"{}"}})"));
         if (val >= std::numeric_limits<double>::lowest() &&
             val <= std::numeric_limits<double>::max())
-            compiled_format_to(buffer, fmtStr, val);
+            format_to(std::back_inserter(buffer), FMT_COMPILE(R"({{"$numberDouble":"{}"}})"), val);
         else if (std::isnan(val))
             appendTo(buffer, R"({"$numberDouble":"NaN"})"_sd);
         else if (std::isinf(val)) {
@@ -89,24 +87,23 @@ public:
     }
 
     void writeDecimal128(fmt::memory_buffer& buffer, Decimal128 val) const {
-        static const auto& fmtStrInfinite =
-            *new auto(fmt::compile<StringData>(R"({{"$numberDecimal":"{}"}})"));
-        static const auto& fmtStrDecimal =
-            *new auto(fmt::compile<std::string>(R"({{"$numberDecimal":"{}"}})"));
         if (val.isNaN())
             appendTo(buffer, R"({"$numberDecimal":"NaN"})"_sd);
         else if (val.isInfinite())
-            compiled_format_to(
-                buffer, fmtStrInfinite, val.isNegative() ? "-Infinity"_sd : "Infinity"_sd);
+            format_to(std::back_inserter(buffer),
+                      FMT_COMPILE(R"({{"$numberDecimal":"{}"}})"),
+                      val.isNegative() ? "-Infinity" : "Infinity");
         else {
-            compiled_format_to(buffer, fmtStrDecimal, val.toString());
+            format_to(std::back_inserter(buffer),
+                      FMT_COMPILE(R"({{"$numberDecimal":"{}"}})"),
+                      val.toString());
         }
     }
 
     void writeDate(fmt::memory_buffer& buffer, Date_t val) const {
-        static const auto& fmtStr =
-            *new auto(fmt::compile<long long>(R"({{"$date":{{"$numberLong":"{}"}}}})"));
-        compiled_format_to(buffer, fmtStr, val.toMillisSinceEpoch());
+        format_to(std::back_inserter(buffer),
+                  FMT_COMPILE(R"({{"$date":{{"$numberLong":"{}"}}}})"),
+                  val.toMillisSinceEpoch());
     }
 
     void writeDBRef(fmt::memory_buffer& buffer, StringData ref, OID id) const {
@@ -115,92 +112,66 @@ public:
         str::escapeForJSON(buffer, ref);
 
         // OID is a hex string and does not need to be escaped
-        static const auto& fmtStr = *new auto(fmt::compile<std::string>(R"(","$id":"{}"}})"));
-        compiled_format_to(buffer, fmtStr, id.toString());
+        format_to(std::back_inserter(buffer), FMT_COMPILE(R"(","$id":"{}"}})"), id.toString());
     }
 
     void writeOID(fmt::memory_buffer& buffer, OID val) const {
         // OID is a hex string and does not need to be escaped
-        static const auto& fmtStr = *new auto(fmt::compile<uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t,
-                                                           uint8_t>(
-            R"({{"$oid":"{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}"}})"));
         static_assert(OID::kOIDSize == 12);
         const uint8_t* data = reinterpret_cast<const uint8_t*>(val.view().view());
-        compiled_format_to(buffer,
-                           fmtStr,
-                           data[0],
-                           data[1],
-                           data[2],
-                           data[3],
-                           data[4],
-                           data[5],
-                           data[6],
-                           data[7],
-                           data[8],
-                           data[9],
-                           data[10],
-                           data[11]);
+        format_to(
+            std::back_inserter(buffer),
+            FMT_COMPILE(
+                R"({{"$oid":"{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}"}})"),
+            data[0],
+            data[1],
+            data[2],
+            data[3],
+            data[4],
+            data[5],
+            data[6],
+            data[7],
+            data[8],
+            data[9],
+            data[10],
+            data[11]);
     }
 
     void writeTimestamp(fmt::memory_buffer& buffer, Timestamp val) const {
-        static const auto& fmtStr = *new auto(
-            fmt::compile<unsigned int, unsigned int>(R"({{"$timestamp":{{"t":{},"i":{}}}}})"));
-        compiled_format_to(buffer, fmtStr, val.getSecs(), val.getInc());
+        format_to(std::back_inserter(buffer),
+                  FMT_COMPILE(R"({{"$timestamp":{{"t":{},"i":{}}}}})"),
+                  val.getSecs(),
+                  val.getInc());
     }
 
     void writeBinData(fmt::memory_buffer& buffer, StringData data, BinDataType type) const {
-        static const auto& fmtStrUuid = *new auto(fmt::compile<uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t,
-                                                               uint8_t>(
-            R"({{"$uuid":"{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}"}})"));
-        static const auto& fmtStrSubtype =
-            *new auto(fmt::compile<BinDataType>(R"(","subType":"{:x}"}}}})"));
         if (type == newUUID && data.size() == 16) {
-            compiled_format_to(buffer,
-                               fmtStrUuid,
-                               static_cast<uint8_t>(data[0]),
-                               static_cast<uint8_t>(data[1]),
-                               static_cast<uint8_t>(data[2]),
-                               static_cast<uint8_t>(data[3]),
-                               static_cast<uint8_t>(data[4]),
-                               static_cast<uint8_t>(data[5]),
-                               static_cast<uint8_t>(data[6]),
-                               static_cast<uint8_t>(data[7]),
-                               static_cast<uint8_t>(data[8]),
-                               static_cast<uint8_t>(data[9]),
-                               static_cast<uint8_t>(data[10]),
-                               static_cast<uint8_t>(data[11]),
-                               static_cast<uint8_t>(data[12]),
-                               static_cast<uint8_t>(data[13]),
-                               static_cast<uint8_t>(data[14]),
-                               static_cast<uint8_t>(data[15]));
+            format_to(
+                std::back_inserter(buffer),
+                FMT_COMPILE(
+                    R"({{"$uuid":"{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}"}})"),
+                static_cast<uint8_t>(data[0]),
+                static_cast<uint8_t>(data[1]),
+                static_cast<uint8_t>(data[2]),
+                static_cast<uint8_t>(data[3]),
+                static_cast<uint8_t>(data[4]),
+                static_cast<uint8_t>(data[5]),
+                static_cast<uint8_t>(data[6]),
+                static_cast<uint8_t>(data[7]),
+                static_cast<uint8_t>(data[8]),
+                static_cast<uint8_t>(data[9]),
+                static_cast<uint8_t>(data[10]),
+                static_cast<uint8_t>(data[11]),
+                static_cast<uint8_t>(data[12]),
+                static_cast<uint8_t>(data[13]),
+                static_cast<uint8_t>(data[14]),
+                static_cast<uint8_t>(data[15]));
         } else {
             appendTo(buffer, R"({"$binary":{"base64":")"_sd);
             base64::encode(buffer, data);
-            compiled_format_to(buffer, fmtStrSubtype, type);
+            format_to(std::back_inserter(buffer),
+                      FMT_COMPILE(R"(","subType":"{:x}"}}}})"),
+                      static_cast<std::underlying_type_t<BSONType>>(type));
         }
     }
 
@@ -248,15 +219,5 @@ protected:
     static void appendTo(fmt::memory_buffer& buffer, const fmt::format_int& data) {
         buffer.append(data.data(), data.data() + data.size());
     }
-
-    template <typename CompiledFormatStr, typename... Args>
-    static void compiled_format_to(fmt::memory_buffer& buffer,
-                                   const CompiledFormatStr& fmt_str,
-                                   const Args&... args) {
-        fmt::internal::cf::vformat_to<fmt::buffer_context<char>>(
-            fmt::buffer_range(buffer),
-            fmt_str,
-            {fmt::make_format_args<fmt::buffer_context<char>>(args...)});
-    }
 };
 }  // namespace mongo
diff --git a/src/mongo/bson/generator_extended_relaxed_2_0_0.h b/src/mongo/bson/generator_extended_relaxed_2_0_0.h
index c310e163090..eccf6bed596 100644
--- a/src/mongo/bson/generator_extended_relaxed_2_0_0.h
+++ b/src/mongo/bson/generator_extended_relaxed_2_0_0.h
@@ -54,20 +54,17 @@ public:
     using ExtendedCanonicalV200Generator::writeUndefined;
 
     void writeInt32(fmt::memory_buffer& buffer, int32_t val) const {
-        fmt::format_int str(val);
-        appendTo(buffer, str);
+        appendTo(buffer, fmt::format_int(val));
     }
 
     void writeInt64(fmt::memory_buffer& buffer, int64_t val) const {
-        fmt::format_int str(val);
-        appendTo(buffer, str);
+        appendTo(buffer, fmt::format_int(val));
     }
 
     void writeDouble(fmt::memory_buffer& buffer, double val) const {
-        static const auto& fmtStr = *new auto(fmt::compile<double>(R"({})"));
         if (val >= std::numeric_limits<double>::lowest() &&
             val <= std::numeric_limits<double>::max())
-            compiled_format_to(buffer, fmtStr, val);
+            format_to(std::back_inserter(buffer), FMT_COMPILE(R"({})"), val);
         else {
             ExtendedCanonicalV200Generator::writeDouble(buffer, val);
         }
@@ -81,9 +78,9 @@ public:
         // handles both the case where Date_t::millis is too large, and the case where
         // Date_t::millis is negative (before the epoch).
         if (val.isFormattable()) {
-            appendTo(buffer, R"({"$date":")"_sd);
-            appendTo(buffer, StringData{DateStringBuffer{}.iso8601(val, _localDate)});
-            appendTo(buffer, R"("})");
+            format_to(std::back_inserter(buffer),
+                      FMT_COMPILE(R"({{"$date":"{}"}})"),
+                      StringData{DateStringBuffer{}.iso8601(val, _localDate)});
         } else {
             ExtendedCanonicalV200Generator::writeDate(buffer, val);
         }