@cpp.Arena is only accepted on fields it can give a PMR type

Summary:
The next diff gives `cpp.Arena` fields PMR C++ types, so `cpp.Arena` is now only accepted on fields that can get one: string, binary, list, set and map fields, with or without `cpp.Type` on any level, that have no default value, reference, `cpp.Lazy`, `folly::IOBuf` C++ type, or adapter on any level of their type.

Before: `cpp.Arena` was accepted on every field except adapted ones, and did nothing.

After: it is accepted only on the fields above, and is an error on any other field. On accepted fields it still does nothing until the next diff.

Reviewed By: iahs

Differential Revision: D129420857

fbshipit-source-id: f057e4ed67a8308b8c1e18dc67d6737373d78713

Author: Mizuchi

thrift/compiler/generate/cpp/util.cc

@@ -17,6 +17,7 @@
 #include <thrift/compiler/generate/cpp/util.h>
 
 #include <algorithm>
+#include <cassert>
 #include <functional>
 #include <memory>
 #include <queue>
@@ -120,6 +121,38 @@ bool is_custom_type(const t_field& field) {
       is_custom_type(*field.type());
 }
 
+namespace {
+bool has_adapted_level(const t_type& type) {
+  if (t_typedef::get_first_structured_annotation_or_null(
+          &type, kCppAdapterUri) != nullptr) {
+    return true;
+  }
+  const t_type* true_type = type.get_true_type();
+  assert(true_type != nullptr);
+  if (const auto* list = true_type->try_as<t_list>()) {
+    return has_adapted_level(*list->elem_type());
+  }
+  if (const auto* set = true_type->try_as<t_set>()) {
+    return has_adapted_level(*set->elem_type());
+  }
+  if (const auto* map = true_type->try_as<t_map>()) {
+    return has_adapted_level(*map->key_type()) ||
+        has_adapted_level(*map->val_type());
+  }
+  return false;
+}
+} // namespace
+
+bool is_arena_supported(const t_field& field) {
+  const t_type* type = field.type()->get_true_type();
+  assert(type != nullptr);
+  return (type->is_string_or_binary() || type->is<t_container>()) &&
+      field.default_value() == nullptr && !is_ref(&field) && !is_lazy(&field) &&
+      !is_binary_iobuf(field) &&
+      !field.has_structured_annotation(kCppAdapterUri) &&
+      !has_adapted_level(*field.type());
+}
+
 bool container_supports_incomplete_params(const t_type& type) {
   if (t_typedef::get_first_structured_annotation_or_null(
           &type,

thrift/compiler/generate/cpp/util.h

@@ -58,6 +58,9 @@ inline std::string get_qualified_name(const t_named& node) {
 bool is_custom_type(const t_field& field);
 bool is_custom_type(const t_type& type);
 
+// Whether field-level `@cpp.Arena` can give the field a PMR C++ type.
+bool is_arena_supported(const t_field& field);
+
 std::unordered_map<const t_type*, std::vector<const t_type*>>
 gen_dependency_graph(
     const t_program* program, const std::vector<const t_type*>& types);

thrift/compiler/sema/standard_validator.cc

@@ -1425,6 +1425,10 @@ void validate_cpp_arena_field(sema_context& ctx, const t_field& field) {
   }
   if (adapter != nullptr) {
     report_cpp_arena_on_adapted(ctx, "field", field.name(), *adapter);
+    return;
+  }
+  if (!cpp2::is_arena_supported(field)) {
+    ctx.error("`@cpp.Arena` is not supported on field `{}`.", field.name());
   }
 }
 

thrift/compiler/test/compiler_test.cc

@@ -3457,6 +3457,46 @@ TEST(CompilerTest, cpp_arena_adapted) {
   )");
 }
 
+TEST(CompilerTest, cpp_arena_unsupported_fields) {
+  check_compile(R"(
+    package "facebook.com/thrift/test"
+    include "thrift/annotation/cpp.thrift"
+    include "thrift/annotation/thrift.thrift"
+
+    @cpp.Adapter{name = "::my::Adapter"}
+    typedef string AdaptedString
+    @cpp.Type{template = "std::deque"}
+    typedef list<string> Deque
+
+    struct Foo {
+      @cpp.Arena
+      1: i32 number;
+        # expected-error@-2: `@cpp.Arena` is not supported on field `number`.
+      @cpp.Arena
+      2: string with_default = "default";
+        # expected-error@-2: `@cpp.Arena` is not supported on field `with_default`.
+      @cpp.Arena
+      @thrift.Box
+      3: optional string boxed;
+        # expected-error@-3: `@cpp.Arena` is not supported on field `boxed`.
+      @cpp.Arena
+      @cpp.Lazy
+      4: list<string> lazy;
+        # expected-error@-3: `@cpp.Arena` is not supported on field `lazy`.
+      @cpp.Arena
+      @cpp.Type{name = "::folly::IOBuf"}
+      5: binary iobuf;
+        # expected-error@-3: `@cpp.Arena` is not supported on field `iobuf`.
+      @cpp.Arena
+      6: list<AdaptedString> adapted_elements;
+        # expected-error@-2: `@cpp.Arena` is not supported on field `adapted_elements`.
+      @cpp.Arena
+      @cpp.Type{template = "std::unordered_map"}
+      7: map<string, Deque> custom;
+    }
+  )");
+}
+
 TEST(CompilerTest, cpp_use_allocator_ref_fields) {
   check_compile(R"(
     package "facebook.com/thrift/test"