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

This reverts commit dc68f885b80e70805eab8c5686ee0941bbdd806b.

2 files changed, 105 insertions, 63 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 cf9ef9c27db..93166c3083b 100644
--- a/src/mongo/bson/generator_extended_canonical_2_0_0.h
+++ b/src/mongo/bson/generator_extended_canonical_2_0_0.h
@@ -35,7 +35,6 @@
 #include "mongo/util/str_escape.h"
 
 #include <fmt/compile.h>
-#include <fmt/format.h>
 
 namespace mongo {
 class ExtendedCanonicalV200Generator {
@@ -61,17 +60,20 @@ public:
     }
 
     void writeInt32(fmt::memory_buffer& buffer, int32_t val) const {
-        format_to(std::back_inserter(buffer), FMT_COMPILE(R"({{"$numberInt":"{}"}})"), val);
+        static const auto& fmtStr = *new auto(fmt::compile<int32_t>(R"({{"$numberInt":"{}"}})"));
+        compiled_format_to(buffer, fmtStr, val);
     }
 
     void writeInt64(fmt::memory_buffer& buffer, int64_t val) const {
-        format_to(std::back_inserter(buffer), FMT_COMPILE(R"({{"$numberLong":"{}"}})"), val);
+        static const auto& fmtStr = *new auto(fmt::compile<int64_t>(R"({{"$numberLong":"{}"}})"));
+        compiled_format_to(buffer, fmtStr, 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())
-            format_to(std::back_inserter(buffer), FMT_COMPILE(R"({{"$numberDouble":"{}"}})"), val);
+            compiled_format_to(buffer, fmtStr, val);
         else if (std::isnan(val))
             appendTo(buffer, R"({"$numberDouble":"NaN"})"_sd);
         else if (std::isinf(val)) {
@@ -87,23 +89,24 @@ 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())
-            format_to(std::back_inserter(buffer),
-                      FMT_COMPILE(R"({{"$numberDecimal":"{}"}})"),
-                      val.isNegative() ? "-Infinity" : "Infinity");
+            compiled_format_to(
+                buffer, fmtStrInfinite, val.isNegative() ? "-Infinity"_sd : "Infinity"_sd);
         else {
-            format_to(std::back_inserter(buffer),
-                      FMT_COMPILE(R"({{"$numberDecimal":"{}"}})"),
-                      val.toString());
+            compiled_format_to(buffer, fmtStrDecimal, val.toString());
         }
     }
 
     void writeDate(fmt::memory_buffer& buffer, Date_t val) const {
-        format_to(std::back_inserter(buffer),
-                  FMT_COMPILE(R"({{"$date":{{"$numberLong":"{}"}}}})"),
-                  val.toMillisSinceEpoch());
+        static const auto& fmtStr =
+            *new auto(fmt::compile<long long>(R"({{"$date":{{"$numberLong":"{}"}}}})"));
+        compiled_format_to(buffer, fmtStr, val.toMillisSinceEpoch());
     }
 
     void writeDBRef(fmt::memory_buffer& buffer, StringData ref, OID id) const {
@@ -112,66 +115,92 @@ public:
         str::escapeForJSON(buffer, ref);
 
         // OID is a hex string and does not need to be escaped
-        format_to(std::back_inserter(buffer), FMT_COMPILE(R"(","$id":"{}"}})"), id.toString());
+        static const auto& fmtStr = *new auto(fmt::compile<std::string>(R"(","$id":"{}"}})"));
+        compiled_format_to(buffer, fmtStr, 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());
-        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]);
+        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]);
     }
 
     void writeTimestamp(fmt::memory_buffer& buffer, Timestamp val) const {
-        format_to(std::back_inserter(buffer),
-                  FMT_COMPILE(R"({{"$timestamp":{{"t":{},"i":{}}}}})"),
-                  val.getSecs(),
-                  val.getInc());
+        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());
     }
 
     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) {
-            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]));
+            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]));
         } else {
             appendTo(buffer, R"({"$binary":{"base64":")"_sd);
             base64::encode(buffer, data);
-            format_to(std::back_inserter(buffer),
-                      FMT_COMPILE(R"(","subType":"{:x}"}}}})"),
-                      static_cast<std::underlying_type_t<BSONType>>(type));
+            compiled_format_to(buffer, fmtStrSubtype, type);
         }
     }
 
@@ -219,5 +248,15 @@ 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 eccf6bed596..c310e163090 100644
--- a/src/mongo/bson/generator_extended_relaxed_2_0_0.h
+++ b/src/mongo/bson/generator_extended_relaxed_2_0_0.h
@@ -54,17 +54,20 @@ public:
     using ExtendedCanonicalV200Generator::writeUndefined;
 
     void writeInt32(fmt::memory_buffer& buffer, int32_t val) const {
-        appendTo(buffer, fmt::format_int(val));
+        fmt::format_int str(val);
+        appendTo(buffer, str);
     }
 
     void writeInt64(fmt::memory_buffer& buffer, int64_t val) const {
-        appendTo(buffer, fmt::format_int(val));
+        fmt::format_int str(val);
+        appendTo(buffer, str);
     }
 
     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())
-            format_to(std::back_inserter(buffer), FMT_COMPILE(R"({})"), val);
+            compiled_format_to(buffer, fmtStr, val);
         else {
             ExtendedCanonicalV200Generator::writeDouble(buffer, val);
         }
@@ -78,9 +81,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()) {
-            format_to(std::back_inserter(buffer),
-                      FMT_COMPILE(R"({{"$date":"{}"}})"),
-                      StringData{DateStringBuffer{}.iso8601(val, _localDate)});
+            appendTo(buffer, R"({"$date":")"_sd);
+            appendTo(buffer, StringData{DateStringBuffer{}.iso8601(val, _localDate)});
+            appendTo(buffer, R"("})");
         } else {
             ExtendedCanonicalV200Generator::writeDate(buffer, val);
         }