Make object manage its own memory and cheap to copy

Summary:
As whisker has evolved, things have become more "dynamic":
  - `native_function` exists and is commonly used
  - property lookups happen mostly via `native_object` or `native_handle<>`.

All of these APIs deal with `object::ptr` (not `object` directly) because they *may* need to be dynamically allocated on the heap.

In future diffs, I plan to move APIs away from `object::ptr` where possible. Because:
* Its use has resulted in the proliferation of `manage_as_static`, `manage_derived`, `manage_derived_ref` everywhere because we need "chains" of `shared_ptr` to avoid copying `whisker::object`. It makes the code hard to read.
* It is pessimistic for the common case (`boolean`, `i64`, `string`, `native_object::ptr` need to be heap-allocated) while "optimizing" for the uncommon case (`array`, `map`).

This diff moves `map` and `array` to use `managed_ptr` to solve the problems above and still avoid deep-copying `map` and `array`. Now, copying `object` is *always* cheap. Since `object` has an immutable API (except move copy/assign), we are fine to share `map` and `array` between instances

Reviewed By: iahs

Differential Revision: D71095233

fbshipit-source-id: 3089b2687f0396b7cef053800c0a454938a7490a

Author: praihan

third-party/thrift/src/thrift/compiler/whisker/dsl.cc

@@ -35,15 +35,15 @@ object::ptr array_like::at(std::size_t index) const {
       [&](const native_object::array_like::ptr& arr) -> object::ptr {
         return arr->at(index);
       },
-      [&](const managed_ptr<array>& arr) -> object::ptr {
+      [&](const managed_array& arr) -> object::ptr {
         return manage_derived_ref(arr, (*arr)[index]);
       });
 }
 
 /* static */ std::optional<array_like> array_like::try_from(
     const object::ptr& o) {
   if (o->is_array()) {
-    return array_like(manage_derived_ref(o, o->as_array()));
+    return array_like(o->as_array());
   }
   if (o->is_native_object()) {
     if (native_object::array_like::ptr arr =
@@ -60,9 +60,9 @@ object::ptr map_like::lookup_property(std::string_view identifier) const {
       [&](const native_object::map_like::ptr& m) -> object::ptr {
         return m->lookup_property(identifier);
       },
-      [&](const managed_ptr<map>& m) -> object::ptr {
+      [&](const managed_map& m) -> object::ptr {
         if (auto it = m->find(identifier); it != m->end()) {
-          return manage_as_static(it->second);
+          return manage_derived_ref(m, it->second);
         }
         return nullptr;
       });
@@ -75,7 +75,7 @@ std::optional<std::set<std::string>> map_like::keys() const {
       [&](const native_object::map_like::ptr& m) -> result {
         return m->keys();
       },
-      [&](const managed_ptr<map>& m) -> result {
+      [&](const managed_map& m) -> result {
         std::set<std::string> keys;
         for (const auto& [key, _] : *m) {
           keys.insert(key);
@@ -86,7 +86,7 @@ std::optional<std::set<std::string>> map_like::keys() const {
 
 /* static */ std::optional<map_like> map_like::try_from(const object::ptr& o) {
   if (o->is_map()) {
-    return map_like(manage_derived_ref(o, o->as_map()));
+    return map_like(o->as_map());
   }
   if (o->is_native_object()) {
     if (native_object::map_like::ptr m = o->as_native_object()->as_map_like()) {

third-party/thrift/src/thrift/compiler/whisker/dsl.h

@@ -28,7 +28,6 @@
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <vector>
 
 namespace whisker::dsl {
 
@@ -53,12 +52,12 @@ class array_like final : public native_object::array_like {
    */
   static std::optional<array_like> try_from(const object::ptr&);
 
-  explicit array_like(native_object::array_like::ptr&& arr)
+  explicit array_like(native_object::array_like::ptr arr)
       : which_(std::move(arr)) {}
-  explicit array_like(managed_ptr<array>&& arr) : which_(std::move(arr)) {}
+  explicit array_like(managed_array arr) : which_(std::move(arr)) {}
 
  private:
-  std::variant<native_object::array_like::ptr, managed_ptr<array>> which_;
+  std::variant<native_object::array_like::ptr, managed_array> which_;
 };
 static_assert(std::is_move_constructible_v<array_like>);
 static_assert(std::is_copy_constructible_v<array_like>);
@@ -81,11 +80,11 @@ class map_like final : public native_object::map_like {
    */
   static std::optional<map_like> try_from(const object::ptr&);
 
-  explicit map_like(native_object::map_like::ptr&& m) : which_(std::move(m)) {}
-  explicit map_like(managed_ptr<map>&& m) : which_(std::move(m)) {}
+  explicit map_like(native_object::map_like::ptr m) : which_(std::move(m)) {}
+  explicit map_like(managed_map m) : which_(std::move(m)) {}
 
  private:
-  std::variant<native_object::map_like::ptr, managed_ptr<map>> which_;
+  std::variant<native_object::map_like::ptr, managed_map> which_;
 };
 static_assert(std::is_move_constructible_v<map_like>);
 static_assert(std::is_copy_constructible_v<map_like>);

third-party/thrift/src/thrift/compiler/whisker/eval_context.cc

@@ -38,7 +38,7 @@ object::ptr find_property(
       [](f64) -> result { return nullptr; },
       [](const string&) -> result { return nullptr; },
       [](boolean) -> result { return nullptr; },
-      [](const array&) -> result { return nullptr; },
+      [](const managed_array&) -> result { return nullptr; },
       [&](const native_object::ptr& o) -> result {
         if (auto map_like = o->as_map_like()) {
           return map_like->lookup_property(identifier.name);
@@ -72,8 +72,8 @@ object::ptr find_property(
         }
         return nullptr;
       },
-      [&](const map& m) -> result {
-        if (auto it = m.find(identifier.name); it != m.end()) {
+      [&](const managed_map& m) -> result {
+        if (auto it = m->find(identifier.name); it != m->end()) {
           return manage_as_static(it->second);
         }
         return nullptr;

third-party/thrift/src/thrift/compiler/whisker/object.cc

@@ -48,8 +48,12 @@ class to_string_visitor {
       typename = std::enable_if_t<std::is_same_v<T, object>>>
   void visit(const T& value, tree_printer::scope scope) const {
     value.visit(
-        [&](const array& a) { visit_maybe_truncate(a, std::move(scope)); },
-        [&](const map& m) { visit_maybe_truncate(m, std::move(scope)); },
+        [&](const managed_array& a) {
+          visit_maybe_truncate(a, std::move(scope));
+        },
+        [&](const managed_map& m) {
+          visit_maybe_truncate(m, std::move(scope));
+        },
         [&](const native_object::ptr& o) {
           visit_maybe_truncate(o, std::move(scope));
         },
@@ -98,20 +102,20 @@ class to_string_visitor {
     scope.println("null");
   }
 
-  void visit(const array& arr, tree_printer::scope scope) const {
+  void visit(const managed_array& arr, tree_printer::scope scope) const {
     require_within_max_depth(scope);
-    scope.println("array (size={})", arr.size());
-    for (std::size_t i = 0; i < arr.size(); ++i) {
+    scope.println("array (size={})", arr->size());
+    for (std::size_t i = 0; i < arr->size(); ++i) {
       auto element_scope = scope.open_transparent_property();
       element_scope.println("[{}]", i);
-      visit(arr[i], element_scope.open_node());
+      visit((*arr)[i], element_scope.open_node());
     }
   }
 
-  void visit(const map& m, tree_printer::scope scope) const {
+  void visit(const managed_map& m, tree_printer::scope scope) const {
     require_within_max_depth(scope);
-    scope.println("map (size={})", m.size());
-    for (const auto& [key, value] : m) {
+    scope.println("map (size={})", m->size());
+    for (const auto& [key, value] : *m) {
       auto element_scope = scope.open_transparent_property();
       element_scope.println("'{}'", key);
       visit(value, element_scope.open_node());
@@ -354,8 +358,8 @@ std::string object::describe_type() const {
       [](const string&) -> std::string { return "string"; },
       [](boolean) -> std::string { return "boolean"; },
       [](null) -> std::string { return "null"; },
-      [](const array&) -> std::string { return "array"; },
-      [](const map&) -> std::string { return "map"; },
+      [](const managed_array&) -> std::string { return "array"; },
+      [](const managed_map&) -> std::string { return "map"; },
       [](const native_object::ptr& o) -> std::string {
         return o->describe_type();
       },