Use for_each_field_id_ascending in Json5ProtocolWriter

Summary: Update StructEncode to use for_each_field_id_ascending when protocol specifies IdAscending field order. Add fieldOrder() method to Json5ProtocolWriter.

Reviewed By: hchokshi

Differential Revision: D94950111

fbshipit-source-id: 30c3a3adc7e06b39169fcb7d0545565624cfd8af

Author: Mizuchi

third-party/thrift/src/thrift/lib/cpp2/op/Get.h

@@ -497,10 +497,14 @@ constexpr void for_each_field_id_ascending_impl(
     std::array<int16_t, N> fieldIds{};
     std::copy_n(pa::field_ids<T>() + 1, N, fieldIds.begin());
     std::sort(fieldIds.begin(), fieldIds.end());
-    return fieldIds;
+    return std::move(fieldIds);
   });
 
-  (f(field_id<sortedFieldIds[I]>{}), ...);
+  // Use array-based expansion instead of fold expression to avoid exceeding
+  // compiler's expression nesting limit for structs with >256 fields.
+  std::array<int, sizeof...(I) + 1> unused{
+      {0, (f(field_id<sortedFieldIds[I]>{}), 0)...}};
+  static_cast<void>(unused);
 }
 
 template <size_t... I, typename F>

third-party/thrift/src/thrift/lib/cpp2/op/detail/Encode.h

@@ -44,6 +44,14 @@ class SimpleJSONProtocolWriter;
 
 namespace op::detail {
 
+template <class Protocol>
+FieldOrder getFieldOrder(const Protocol& prot) {
+  if constexpr (requires { prot.fieldOrder(); }) {
+    return prot.fieldOrder();
+  }
+  return FieldOrder::Serialization;
+}
+
 template <typename T, typename Tag>
 inline constexpr bool kIsStrongType =
     std::is_enum_v<folly::remove_cvref_t<T>> &&
@@ -549,13 +557,8 @@ struct StructEncode {
   uint32_t operator()(Protocol& prot, const T& t) const {
     uint32_t s = 0;
     s += prot.writeStructBegin(op::get_class_name_v<T>.data());
-    op::for_each_ordinal<T>([&](auto id) {
-      // To respect the SerializeInFieldIdOrder annotation, we perform a custom
-      // mapping to FieldId that may switch the current ordinal being visited.
-      // This new field id is the source of truth, and the old ordinal value
-      // should not be used in this function.
-      using Id = type::field_id<detail::pa::field_ids_in_serialization_order<
-          T>()[static_cast<size_t>(decltype(id)::value)]>;
+    auto writeField = [&]<class Id>(Id) {
+      static_assert(type::is_field_id_v<Id>);
       using TypeTag = op::get_type_tag<T, Id>;
       using FieldTag = op::get_field_tag<T, Id>;
       auto&& field = op::get<Id>(t);
@@ -569,7 +572,20 @@ struct StructEncode {
           folly::to_underlying(Id::value));
       s += Encode<TypeTag>{}(prot, *field);
       s += prot.writeFieldEnd();
-    });
+    };
+    if (getFieldOrder(prot) == FieldOrder::Serialization) {
+      op::for_each_ordinal<T>([&](auto id) {
+        // To respect the SerializeInFieldIdOrder annotation, we perform a
+        // custom mapping to FieldId that may switch the current ordinal being
+        // visited. This new field id is the source of truth, and the old
+        // ordinal value should not be used in this function.
+        using Id = type::field_id<detail::pa::field_ids_in_serialization_order<
+            T>()[static_cast<size_t>(decltype(id)::value)]>;
+        writeField(Id{});
+      });
+    } else {
+      op::for_each_field_id_ascending<T>(writeField);
+    }
     s += prot.writeFieldStop();
     s += prot.writeStructEnd();
     return s;

third-party/thrift/src/thrift/lib/cpp2/protocol/Protocol.h

@@ -459,6 +459,15 @@ constexpr bool usesFieldNames() {
   }
 }
 
+/// Specifies the order in which struct fields are serialized.
+enum class FieldOrder {
+  /// Field declaration order in IDL, unless SerializeInFieldIdOrder annotation
+  /// is present, in which case field id ascending order.
+  Serialization,
+  /// Field id ascending order (1, 2, 3, ...).
+  IdAscending,
+};
+
 } // namespace apache::thrift
 
 #endif