Implement Container V2 for std::unordered_map

test/integration/std_unordered_map_custom_operator.toml

@@ -33,7 +33,6 @@ includes = ["unordered_map"]
 
 [cases]
   [cases.a]
-    oil_skip = "std::unordered_map is not implemented for treebuilder v2" # https://github.com/facebookexperimental/object-introspection/issues/303
     param_types = ["const Foo&"]
     setup = '''
       Foo foo;
@@ -65,3 +64,11 @@ includes = ["unordered_map"]
         {"name":"m3", "staticSize":120, "dynamicSize":328, "length":7, "capacity":7, "elementStaticSize":32},
         {"name":"m4", "staticSize":184, "dynamicSize":392, "length":9, "capacity":9, "elementStaticSize":32}
       ]}]'''
+    expect_json_v2 = '''[{
+      "staticSize":480,
+      "members":[
+        {"name":"m1", "staticSize":56, "exclusiveSize":220, "length":3, "capacity":3},
+        {"name":"m2", "staticSize":120, "exclusiveSize":324, "length":5, "capacity":5},
+        {"name":"m3", "staticSize":120, "exclusiveSize":364, "length":7, "capacity":7},
+        {"name":"m4", "staticSize":184, "exclusiveSize":468, "length":9, "capacity":9}
+      ]}]'''

types/std_unordered_map_type.toml

@@ -74,3 +74,91 @@ struct TypeHandler<DB, %1%<T0, T1, T2, T3, T4>> {
   }
 };
 """
+
+traversal_func = """
+auto tail = returnArg
+  .write((uintptr_t)&container)
+  .write(container.bucket_count())
+  .write(container.size());
+
+for (const auto &it : container) {
+  tail = tail.delegate([&it](auto ret) {
+    return OIInternal::getSizeType<DB>(it, ret);
+  });
+}
+
+return tail.finish();
+"""
+
+[[codegen.processor]]
+type = "types::st::VarInt<DB>"
+func = """
+el.pointer = std::get<ParsedData::VarInt>(d.val).value;
+"""
+
+[[codegen.processor]]
+type = "types::st::VarInt<DB>"
+func = """
+// Using the container's capacity to temporarily store the number of buckets
+// TODO: Is there another way to pass a value across processors?
+el.container_stats.emplace(result::Element::ContainerStats {
+  .capacity = std::get<ParsedData::VarInt>(d.val).value,
+});
+"""
+
+[[codegen.processor]]
+type = """
+types::st::List<DB, types::st::Pair<DB,
+  typename TypeHandler<DB, T0>::type,
+  typename TypeHandler<DB, T1>::type>>
+"""
+func = """
+#ifdef __GLIBCXX__
+/* Use libstdc++ implementation __details to compute the size of Nodes and Buckets.
+ *
+ * See the source of <bits/hashtable_policy.h>:
+ * https://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a00536_source.html
+ */
+using OI_value_type = std::pair<const T0, T1>;
+using OI_Hash_node =
+  std::__detail::_Hash_node<
+    OI_value_type,
+    std::__cache_default<OI_value_type, T2>::value>;
+
+using OI_bucket = std::__detail::_Hash_node_base;
+
+static constexpr size_t element_size = sizeof(OI_Hash_node);
+static constexpr size_t bucket_size = sizeof(OI_bucket);
+#else
+static_assert(false && "No known element_size for sets. See types/set_type.toml");
+#endif
+
+auto list = std::get<ParsedData::List>(d.val);
+// Reading the bucket count that was stored in `capacity` by the processor above.
+size_t bucket_count = el.container_stats->capacity;
+el.exclusive_size += bucket_count * bucket_size;
+el.exclusive_size += list.length * (element_size - sizeof(T0));
+
+// Overwrite the bucket count stored in `capacity` with the actual container's values.
+el.container_stats.emplace(result::Element::ContainerStats {
+  .capacity = list.length,
+  .length = list.length,
+});
+
+static constexpr std::array<inst::Field, 2> element_fields{
+  make_field<DB, T0>("key"),
+  make_field<DB, T1>("value"),
+};
+
+static constexpr auto element = inst::Field{
+  element_size,
+  element_size - sizeof(T0) - sizeof(T1),
+  "[]",
+  std::array<std::string_view, 0>{},
+  element_fields,
+  std::array<inst::ProcessorInst, 0>{},
+};
+
+for (size_t i = 0; i < list.length; i++)
+  ins.emplace(element);
+"""