Revert D94950111: Use for_each_field_id_ascending in Json5ProtocolWriter

Differential Revision:
D94950111

Original commit changeset: 30c3a3adc7e0

Original Phabricator Diff: D94950111

fbshipit-source-id: bd6f6c6f1ce8370222a34bdfce8e40fa3b2d97f7

Author: Mizuchi

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

@@ -497,14 +497,10 @@ 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 std::move(fieldIds);
+    return fieldIds;
   });
 
-  // 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);
+  (f(field_id<sortedFieldIds[I]>{}), ...);
 }
 
 template <size_t... I, typename F>

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

@@ -44,14 +44,6 @@ 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>> &&
@@ -557,8 +549,13 @@ 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());
-    auto writeField = [&]<class Id>(Id) {
-      static_assert(type::is_field_id_v<Id>);
+    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)]>;
       using TypeTag = op::get_type_tag<T, Id>;
       using FieldTag = op::get_field_tag<T, Id>;
       auto&& field = op::get<Id>(t);
@@ -572,20 +569,7 @@ 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

@@ -460,15 +460,6 @@ 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