Allow dynamically building ListValue, MapValue, and StructValue

PiperOrigin-RevId: 534106408

Author: jcking

base/BUILD

@@ -46,6 +46,7 @@ cc_library(
     deps = [
         "//base/internal:data",
         "//base/internal:handle",
+        "@com_google_absl//absl/base",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/log:absl_check",
     ],

base/handle.h

@@ -15,10 +15,14 @@
 #ifndef THIRD_PARTY_CEL_CPP_BASE_HANDLE_H_
 #define THIRD_PARTY_CEL_CPP_BASE_HANDLE_H_
 
+#include <memory>
+#include <string>
 #include <type_traits>
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/base/casts.h"
+#include "absl/base/macros.h"
 #include "absl/log/absl_check.h"
 #include "base/internal/data.h"
 #include "base/internal/handle.h"  // IWYU pragma: export
@@ -302,6 +306,52 @@ struct HandleFactory {
   template <typename F, typename... Args>
   static std::enable_if_t<IsDerivedHeapDataV<F>, Handle<T>> Make(
       MemoryManager& memory_manager, Args&&... args);
+
+  // Constructs a handle from `*this` for classes which extend `Type` and
+  // `Value`.
+  template <typename F>
+  static Handle<T> FromThis(F& self) {
+    if constexpr (std::is_base_of_v<InlineData, F>) {
+      // If F is derived from InlineData, we don't need to perform runtime
+      // checks. This is selected at compile time.
+      return Handle<T>(*absl::bit_cast<const Handle<F>*>(
+          static_cast<Data*>(std::addressof(self))));
+    }
+    if constexpr (std::is_base_of_v<HeapData, F>) {
+      // If F is derived from HeapData, we don't need to perform runtime checks.
+      // This is selected at compile time.
+      if (Metadata::IsReferenceCounted(self)) {
+        Metadata::Ref(self);
+        return Handle<T>(kInPlaceReferenceCounted, self);
+      }
+      // Must be arena allocated.
+      ABSL_ASSERT(Metadata::IsArenaAllocated(self));
+      return Handle<T>(kInPlaceArenaAllocated, self);
+    }
+    // Perform runtime checks, F is not derived from InlineData or HeapData so
+    // it must be a abstract base class.
+    if (Metadata::IsStoredInline(self)) {
+      return Handle<T>(*absl::bit_cast<const Handle<F>*>(
+          static_cast<Data*>(std::addressof(self))));
+    }
+    // Must be heap allocated.
+    if (Metadata::IsReferenceCounted(self)) {
+      Metadata::Ref(self);
+      return Handle<T>(kInPlaceReferenceCounted, self);
+    }
+    // Must be arena allocated.
+    ABSL_ASSERT(Metadata::IsArenaAllocated(self));
+    return Handle<T>(kInPlaceArenaAllocated, self);
+  }
+};
+
+template <typename BaseT, typename DerivedT>
+struct EnableHandleFromThis {
+ protected:
+  Handle<BaseT> handle_from_this() const {
+    return HandleFactory<BaseT>::FromThis(
+        const_cast<DerivedT&>(*reinterpret_cast<const DerivedT*>(this)));
+  }
 };
 
 }  // namespace cel::base_internal

base/types/list_type.cc

@@ -22,7 +22,12 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "base/internal/data.h"
+#include "base/kind.h"
+#include "base/memory.h"
 #include "base/types/dyn_type.h"
+#include "base/value_factory.h"
+#include "base/values/list_value.h"
+#include "base/values/list_value_builder.h"
 
 namespace cel {
 
@@ -48,6 +53,40 @@ const Handle<Type>& ListType::element() const {
   return static_cast<const base_internal::ModernListType&>(*this).element();
 }
 
+absl::StatusOr<UniqueRef<ListValueBuilderInterface>> ListType::NewValueBuilder(
+    ValueFactory& value_factory) const {
+  switch (element()->kind()) {
+    case Kind::kBool:
+      return MakeUnique<ListValueBuilder<BoolValue>>(
+          value_factory.memory_manager(), base_internal::kComposedListType,
+          value_factory, handle_from_this());
+    case Kind::kInt:
+      return MakeUnique<ListValueBuilder<IntValue>>(
+          value_factory.memory_manager(), base_internal::kComposedListType,
+          value_factory, handle_from_this());
+    case Kind::kUint:
+      return MakeUnique<ListValueBuilder<UintValue>>(
+          value_factory.memory_manager(), base_internal::kComposedListType,
+          value_factory, handle_from_this());
+    case Kind::kDouble:
+      return MakeUnique<ListValueBuilder<DoubleValue>>(
+          value_factory.memory_manager(), base_internal::kComposedListType,
+          value_factory, handle_from_this());
+    case Kind::kDuration:
+      return MakeUnique<ListValueBuilder<DurationValue>>(
+          value_factory.memory_manager(), base_internal::kComposedListType,
+          value_factory, handle_from_this());
+    case Kind::kTimestamp:
+      return MakeUnique<ListValueBuilder<TimestampValue>>(
+          value_factory.memory_manager(), base_internal::kComposedListType,
+          value_factory, handle_from_this());
+    default:
+      return MakeUnique<ListValueBuilder<Value>>(
+          value_factory.memory_manager(), base_internal::kComposedListType,
+          value_factory, handle_from_this());
+  }
+}
+
 namespace base_internal {
 
 const Handle<Type>& LegacyListType::element() const {

base/types/list_type.h

@@ -19,9 +19,12 @@
 #include <cstdint>
 #include <string>
 
+#include "absl/base/attributes.h"
 #include "absl/log/absl_check.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "base/handle.h"
 #include "base/internal/data.h"
 #include "base/kind.h"
 #include "base/memory.h"
@@ -31,10 +34,14 @@ namespace cel {
 
 class MemoryManager;
 class ListValue;
+class ValueFactory;
+class ListValueBuilderInterface;
 
 // ListType represents a list type. A list is a sequential container where each
 // element is the same type.
-class ListType : public Type {
+class ListType
+    : public Type,
+      public base_internal::EnableHandleFromThis<ListType, ListType> {
  public:
   static constexpr Kind kKind = Kind::kList;
 
@@ -56,6 +63,10 @@ class ListType : public Type {
     return static_cast<const ListType&>(type);
   }
 
+  absl::StatusOr<UniqueRef<ListValueBuilderInterface>> NewValueBuilder(
+      ValueFactory& value_factory
+          ABSL_ATTRIBUTE_LIFETIME_BOUND) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
  private:
   friend class Type;
   friend class MemoryManager;

base/types/map_type.cc

@@ -22,7 +22,12 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "base/internal/data.h"
+#include "base/kind.h"
+#include "base/memory.h"
 #include "base/types/dyn_type.h"
+#include "base/value_factory.h"
+#include "base/values/map_value.h"
+#include "base/values/map_value_builder.h"
 
 namespace cel {
 
@@ -56,6 +61,54 @@ const Handle<Type>& MapType::value() const {
   return static_cast<const base_internal::ModernMapType&>(*this).value();
 }
 
+namespace {
+
+template <typename K>
+absl::StatusOr<UniqueRef<MapValueBuilderInterface>> NewMapValueBuilderFor(
+    ValueFactory& value_factory, Handle<MapType> type) {
+  switch (type->value()->kind()) {
+    case Kind::kBool:
+      return MakeUnique<MapValueBuilder<K, BoolValue>>(
+          value_factory.memory_manager(), value_factory, std::move(type));
+    case Kind::kInt:
+      return MakeUnique<MapValueBuilder<K, IntValue>>(
+          value_factory.memory_manager(), value_factory, std::move(type));
+    case Kind::kUint:
+      return MakeUnique<MapValueBuilder<K, UintValue>>(
+          value_factory.memory_manager(), value_factory, std::move(type));
+    case Kind::kDouble:
+      return MakeUnique<MapValueBuilder<K, DoubleValue>>(
+          value_factory.memory_manager(), value_factory, std::move(type));
+    case Kind::kDuration:
+      return MakeUnique<MapValueBuilder<K, DurationValue>>(
+          value_factory.memory_manager(), value_factory, std::move(type));
+    case Kind::kTimestamp:
+      return MakeUnique<MapValueBuilder<K, TimestampValue>>(
+          value_factory.memory_manager(), value_factory, std::move(type));
+    default:
+      return MakeUnique<MapValueBuilder<K, Value>>(
+          value_factory.memory_manager(), value_factory, std::move(type));
+  }
+}
+
+}  // namespace
+
+absl::StatusOr<UniqueRef<MapValueBuilderInterface>> MapType::NewValueBuilder(
+    ValueFactory& value_factory) const {
+  switch (key()->kind()) {
+    case Kind::kBool:
+      return NewMapValueBuilderFor<BoolValue>(value_factory,
+                                              handle_from_this());
+    case Kind::kInt:
+      return NewMapValueBuilderFor<IntValue>(value_factory, handle_from_this());
+    case Kind::kUint:
+      return NewMapValueBuilderFor<UintValue>(value_factory,
+                                              handle_from_this());
+    default:
+      return NewMapValueBuilderFor<Value>(value_factory, handle_from_this());
+  }
+}
+
 namespace base_internal {
 
 const Handle<Type>& LegacyMapType::key() const {

base/types/map_type.h

@@ -19,9 +19,12 @@
 #include <cstdint>
 #include <string>
 
+#include "absl/base/attributes.h"
 #include "absl/log/absl_check.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "base/handle.h"
 #include "base/internal/data.h"
 #include "base/kind.h"
 #include "base/memory.h"
@@ -32,10 +35,13 @@ namespace cel {
 class MemoryManager;
 class TypeFactory;
 class MapValue;
+class ValueFactory;
+class MapValueBuilderInterface;
 
 // MapType represents a map type. A map is container of key and value pairs
 // where each key appears at most once.
-class MapType : public Type {
+class MapType : public Type,
+                public base_internal::EnableHandleFromThis<MapType, MapType> {
  public:
   static constexpr Kind kKind = Kind::kMap;
 
@@ -60,6 +66,10 @@ class MapType : public Type {
   // Returns the type of the values in the map.
   const Handle<Type>& value() const;
 
+  absl::StatusOr<UniqueRef<MapValueBuilderInterface>> NewValueBuilder(
+      ValueFactory& value_factory
+          ABSL_ATTRIBUTE_LIFETIME_BOUND) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
  private:
   friend class Type;
   friend class MemoryManager;

base/types/struct_type.cc

@@ -23,6 +23,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
+#include "base/values/struct_value_builder.h"
 #include "internal/overloaded.h"
 #include "internal/status_macros.h"
 
@@ -105,6 +106,11 @@ StructType::NewFieldIterator(MemoryManager& memory_manager) const {
   return CEL_INTERNAL_STRUCT_TYPE_DISPATCH(NewFieldIterator, memory_manager);
 }
 
+absl::StatusOr<UniqueRef<StructValueBuilderInterface>>
+StructType::NewValueBuilder(ValueFactory& value_factory) const {
+  return CEL_INTERNAL_STRUCT_TYPE_DISPATCH(NewValueBuilder, value_factory);
+}
+
 #undef CEL_INTERNAL_STRUCT_TYPE_DISPATCH
 
 struct StructType::FindFieldVisitor final {
@@ -182,6 +188,14 @@ LegacyStructType::FindFieldByNumber(TypeManager& type_manager,
       "Legacy struct type does not support type introspection");
 }
 
+absl::StatusOr<UniqueRef<StructValueBuilderInterface>>
+LegacyStructType::NewValueBuilder(ValueFactory& value_factory) const {
+  return absl::UnimplementedError(
+      "StructType::NewValueBuilder is unimplemented. Perhaps the value library "
+      "is not linked into your binary or StructType::NewValueBuilder was not "
+      "overridden?");
+}
+
 AbstractStructType::AbstractStructType()
     : StructType(), base_internal::HeapData(kKind) {
   // Ensure `Type*` and `base_internal::HeapData*` are not thunked.
@@ -190,6 +204,14 @@ AbstractStructType::AbstractStructType()
       reinterpret_cast<uintptr_t>(static_cast<base_internal::HeapData*>(this)));
 }
 
+absl::StatusOr<UniqueRef<StructValueBuilderInterface>>
+AbstractStructType::NewValueBuilder(ValueFactory& value_factory) const {
+  return absl::UnimplementedError(
+      "StructType::NewValueBuilder is unimplemented. Perhaps the value library "
+      "is not linked into your binary or StructType::NewValueBuilder was not "
+      "overridden?");
+}
+
 }  // namespace base_internal
 
 }  // namespace cel

base/types/struct_type.h

@@ -27,6 +27,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
+#include "base/handle.h"
 #include "base/internal/data.h"
 #include "base/kind.h"
 #include "base/memory.h"
@@ -43,6 +44,8 @@ class MemoryManager;
 class StructValue;
 class TypedStructValueFactory;
 class TypeManager;
+class StructValueBuilderInterface;
+class ValueFactory;
 
 // StructType represents an struct type. An struct is a set of fields
 // that can be looked up by name and/or number.
@@ -133,6 +136,10 @@ class StructType : public Type {
   absl::StatusOr<UniqueRef<FieldIterator>> NewFieldIterator(
       MemoryManager& memory_manager) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
 
+  absl::StatusOr<UniqueRef<StructValueBuilderInterface>> NewValueBuilder(
+      ValueFactory& value_factory
+          ABSL_ATTRIBUTE_LIFETIME_BOUND) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
  protected:
   static FieldId MakeFieldId(absl::string_view name) { return FieldId(name); }
 
@@ -256,6 +263,10 @@ class LegacyStructType final : public StructType, public InlineData {
   absl::StatusOr<UniqueRef<FieldIterator>> NewFieldIterator(
       MemoryManager& memory_manager) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
 
+  absl::StatusOr<UniqueRef<StructValueBuilderInterface>> NewValueBuilder(
+      ValueFactory& value_factory
+          ABSL_ATTRIBUTE_LIFETIME_BOUND) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
  private:
   static constexpr uintptr_t kMetadata =
       kStoredInline | kTrivial | (static_cast<uintptr_t>(kKind) << kKindShift);
@@ -279,7 +290,10 @@ class LegacyStructType final : public StructType, public InlineData {
   uintptr_t msg_;
 };
 
-class AbstractStructType : public StructType, public HeapData {
+class AbstractStructType
+    : public StructType,
+      public HeapData,
+      public EnableHandleFromThis<StructType, AbstractStructType> {
  public:
   static bool Is(const Type& type) {
     return StructType::Is(type) &&
@@ -313,6 +327,10 @@ class AbstractStructType : public StructType, public HeapData {
   virtual absl::StatusOr<UniqueRef<FieldIterator>> NewFieldIterator(
       MemoryManager& memory_manager) const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0;
 
+  virtual absl::StatusOr<UniqueRef<StructValueBuilderInterface>>
+  NewValueBuilder(ValueFactory& value_factory ABSL_ATTRIBUTE_LIFETIME_BOUND)
+      const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
  protected:
   AbstractStructType();