Add to_type_array helper to base Whisker generator

Summary: Add `to_type_array` helper to return most-derived prototype for a collection of `t_type` elements.

Reviewed By: praihan

Differential Revision: D95302151

fbshipit-source-id: 074d5fcdc2179d3c370768203c31135050f18b31

Author: hchokshi

third-party/thrift/src/thrift/compiler/generate/t_mstch_go_generator.cc

@@ -149,12 +149,7 @@ class t_mstch_go_generator : public t_whisker_generator {
       return to_array(data_.req_resp_structs, proto.of<t_struct>());
     });
     def.property("thrift_metadata_types", [this, &proto](const t_program&) {
-      whisker::array::raw result;
-      result.reserve(data_.thrift_metadata_types.size());
-      for (const t_type* type : data_.thrift_metadata_types) {
-        result.emplace_back(resolve_derived_t_type(proto, *type));
-      }
-      return whisker::array::of(std::move(result));
+      return to_type_array(data_.thrift_metadata_types, proto);
     });
 
     return std::move(def).make();

third-party/thrift/src/thrift/compiler/generate/t_mstch_py3_generator.cc

@@ -1016,7 +1016,7 @@ class t_mstch_py3_generator : public t_mstch_generator {
           visible.reserve(self.structured_definitions().size());
           for (const t_structured* s : self.structured_definitions()) {
             if (!is_hidden(*s)) {
-              visible.emplace_back(proto.create<t_structured>(*s));
+              visible.emplace_back(resolve_derived_t_type(proto, *s));
             }
           }
           return whisker::make::array(std::move(visible));
@@ -1104,10 +1104,10 @@ class t_mstch_py3_generator : public t_mstch_generator {
           !context_->stream_types(self).empty();
     });
     def.property("custom_templates", [&](const t_program& self) {
-      return to_array(context_->custom_templates(self), proto.of<t_type>());
+      return to_type_array(context_->custom_templates(self), proto);
     });
     def.property("custom_cpp_types", [&](const t_program& self) {
-      return to_array(context_->custom_cpp_types(self), proto.of<t_type>());
+      return to_type_array(context_->custom_cpp_types(self), proto);
     });
 
     return std::move(def).make();

third-party/thrift/src/thrift/compiler/generate/t_whisker_generator.cc

@@ -607,12 +607,7 @@ prototype<t_program>::ptr t_whisker_generator::make_prototype_for_program(
       });
 
   def.property("structured_definitions", [&](const t_program& self) {
-    array::raw result;
-    result.reserve(self.structured_definitions().size());
-    for (const t_structured* structured : self.structured_definitions()) {
-      result.emplace_back(resolve_derived_t_type(proto, *structured));
-    }
-    return array::of(std::move(result));
+    return to_type_array(self.structured_definitions(), proto);
   });
   def.property("services", mem_fn(&t_program::services, proto.of<t_service>()));
   def.property(
@@ -736,8 +731,7 @@ prototype<t_function>::ptr t_whisker_generator::make_prototype_for_function(
   def.property("stream", mem_fn(&t_function::stream, proto.of<t_stream>()));
 
   def.property("return_type", [&](const t_function& function) {
-    const t_type* type = function.return_type().get_type();
-    return resolve_derived_t_type(proto, *type);
+    return resolve_derived_t_type(proto, function.return_type().deref());
   });
 
   def.property("oneway?", [](const t_function& self) {

third-party/thrift/src/thrift/compiler/generate/t_whisker_generator.h

@@ -460,13 +460,16 @@ class t_whisker_generator : public t_generator {
    */
   template <typename T>
   static auto to_array(node_list_view<const T> nodes, prototype_ptr<T> proto) {
+    static_assert(
+        !std::is_same_v<t_type, std::remove_cv_t<T>>,
+        "Use `to_type_array` for lists of `t_type`, to avoid bugs with incorrect derived prototype resolution");
     whisker::array::raw refs;
     refs.reserve(nodes.size());
     for (const T& ref : nodes) {
       refs.emplace_back(
           whisker::make::native_handle(whisker::manage_as_static(ref), proto));
     }
-    return whisker::make::array(refs);
+    return whisker::make::array(std::move(refs));
   }
 
   /**
@@ -475,13 +478,31 @@ class t_whisker_generator : public t_generator {
   template <typename T>
   static auto to_array(
       const std::vector<T*>& nodes, prototype_ptr<std::remove_cv_t<T>> proto) {
+    static_assert(
+        !std::is_same_v<t_type, std::remove_cv_t<T>>,
+        "Use `to_type_array` for lists of `t_type`, to avoid bugs with incorrect derived prototype resolution");
     whisker::array::raw refs;
     refs.reserve(nodes.size());
     for (const T* ref : nodes) {
       refs.emplace_back(
           whisker::make::native_handle(whisker::manage_as_static(*ref), proto));
     }
-    return whisker::make::array(refs);
+    return whisker::make::array(std::move(refs));
+  }
+
+  /**
+   * Converts a container of `t_type` instances to a Whisker array, resolving
+   * the most derived prototype for each element.
+   */
+  template <typename T>
+  static auto to_type_array(
+      const std::vector<T*>& nodes, const prototype_database& proto) {
+    whisker::array::raw refs;
+    refs.reserve(nodes.size());
+    for (const T* ref : nodes) {
+      refs.emplace_back(resolve_derived_t_type(proto, *ref));
+    }
+    return whisker::make::array(std::move(refs));
   }
 
   /**