Add customization to CppType and Adapter for RecursiveEncode

Summary: Currently RecursiveEncode cannot handle cpp type and adapted type. This diff added such support.

Reviewed By: vitaut

Differential Revision: D44309830

fbshipit-source-id: d7a10e9ef5c4114f15e443cf60e29ee969fd82bb

Author: Mizuchi

thrift/lib/cpp2/op/detail/Encode.h

@@ -521,25 +521,37 @@ struct MapEncode {
 template <typename Key, typename Value>
 struct Encode<type::map<Key, Value>> : MapEncode<Key, Value> {};
 
-template <typename T, typename Tag>
-struct Encode<type::cpp_type<T, Tag>> : Encode<Tag> {
+template <
+    typename T,
+    typename Tag,
+    template <class...> class EncodeImpl = Encode>
+struct CppTypeEncode {
   template <class Protocol, class U>
   uint32_t operator()(Protocol& prot, const U& m) const {
     auto f = folly::if_constexpr<kIsStrongType<U, Tag>>(
         [](auto& v) { return static_cast<type::native_type<Tag>>(v); },
         folly::identity);
-    return Encode<Tag>::operator()(prot, f(m));
+    return EncodeImpl<Tag>{}(prot, f(m));
   }
 };
 
-template <typename Adapter, typename Tag>
-struct Encode<type::adapted<Adapter, Tag>> {
+template <typename T, typename Tag>
+struct Encode<type::cpp_type<T, Tag>> : CppTypeEncode<T, Tag> {};
+
+template <
+    typename Adapter,
+    typename Tag,
+    template <class...> class EncodeImpl = Encode>
+struct AdaptedEncode {
   template <typename Protocol, typename U>
   uint32_t operator()(Protocol& prot, const U& m) const {
-    return Encode<Tag>{}(prot, Adapter::toThrift(m));
+    return EncodeImpl<Tag>{}(prot, Adapter::toThrift(m));
   }
 };
 
+template <typename Adapter, typename Tag>
+struct Encode<type::adapted<Adapter, Tag>> : AdaptedEncode<Adapter, Tag> {};
+
 template <typename>
 struct Decode;
 
@@ -927,6 +939,18 @@ template <class T>
 struct RecursiveEncode<type::union_t<T>> : RecursiveEncode<type::struct_t<T>> {
 };
 
+template <class T>
+struct RecursiveEncode<type::exception_t<T>>
+    : RecursiveEncode<type::struct_t<T>> {};
+
+template <typename T, typename Tag>
+struct RecursiveEncode<type::cpp_type<T, Tag>>
+    : CppTypeEncode<T, Tag, RecursiveEncode> {};
+
+template <typename Adapter, typename Tag>
+struct RecursiveEncode<type::adapted<Adapter, Tag>>
+    : AdaptedEncode<Adapter, Tag, RecursiveEncode> {};
+
 template <typename T>
 FOLLY_INLINE_VARIABLE constexpr RecursiveEncode<type::infer_tag<T>>
     recursive_encode{};

thrift/test/RecursiveEncode.thrift

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+include "thrift/annotation/cpp.thrift"
+cpp_include "thrift/test/AdapterTest.h"
+cpp_include "<list>"
+
+package "apache.org/thrift/test"
+
+struct Foo {
+  1: i32 field;
+}
+
+typedef list<Foo> (cpp.type = "std::list<::apache::thrift::test::Foo>") FooList
+
+@cpp.Adapter{name = "::apache::thrift::test::TemplatedTestAdapter"}
+struct Bar {
+  1: i32 field;
+  2: FooList foos;
+}
+
+struct Baz {
+  1: i32 field;
+  @cpp.Adapter{name = "::apache::thrift::test::TemplatedTestAdapter"}
+  2: Bar bar;
+}

thrift/test/RecursiveEncodeTest.cpp

@@ -17,29 +17,31 @@
 #include <folly/portability/GTest.h>
 #include <thrift/lib/cpp2/op/Encode.h>
 #include <thrift/lib/cpp2/protocol/Serializer.h>
+#include <thrift/test/gen-cpp2/RecursiveEncode_types.h>
 #include <thrift/test/testset/Populator.h>
 
 namespace apache::thrift::test {
 
 namespace {
+template <typename SerializerT, typename T>
+void roundTripTest(T obj) {
+  folly::IOBufQueue buffer;
+  typename SerializerT::ProtocolWriter writer;
+  writer.setOutput(&buffer);
+  op::detail::recursive_encode<T>(writer, obj);
+  T obj2 = SerializerT::template deserialize<T>(buffer.move().get());
+  EXPECT_EQ(obj, obj2);
+}
 
 template <typename T>
 class RecursiveEncodeTest : public testing::Test {
  private:
   std::mt19937 rng_;
 
  protected:
-  T populated() { return populated_if_not_adapted<T>(rng_); }
-
   template <typename SerializerT>
   void testSerializer() {
-    T obj = this->populated();
-    folly::IOBufQueue buffer;
-    typename SerializerT::ProtocolWriter writer;
-    writer.setOutput(&buffer);
-    op::detail::recursive_encode<T>(writer, obj);
-    T obj2 = SerializerT::template deserialize<T>(buffer.move().get());
-    EXPECT_EQ(obj, obj2);
+    roundTripTest<SerializerT>(populated_if_not_adapted<T>(rng_));
   }
 };
 
@@ -61,5 +63,23 @@ REGISTER_TYPED_TEST_CASE_P(RecursiveEncodeTest, Compact, Binary, SimpleJson);
 
 THRIFT_INST_TESTSET_ALL(RecursiveEncodeTest);
 
+TEST(RecursiveEncode, TestCustomType) {
+  Baz baz;
+  baz.field() = 10;
+  auto& bar = baz.bar()->value.value;
+  bar.field() = 20;
+
+  Foo foo1, foo2;
+  foo1.field() = 30;
+  foo2.field() = 40;
+
+  bar.foos()->push_back(foo1);
+  bar.foos()->push_back(foo2);
+
+  roundTripTest<CompactSerializer>(baz);
+  roundTripTest<BinarySerializer>(baz);
+  roundTripTest<SimpleJSONSerializer>(baz);
+}
+
 } // namespace
 } // namespace apache::thrift::test