Update the LegacyTypeProvider to proxy to the normal implementation for field lookups.

PiperOrigin-RevId: 959940867

Author: jnthntatum

eval/compiler/BUILD

@@ -139,7 +139,6 @@ cc_library(
         "//runtime/internal:issue_collector",
         "//runtime/internal:runtime_env",
         "@com_google_absl//absl/algorithm:container",
-        "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
@@ -150,7 +149,6 @@ cc_library(
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:optional",
         "@com_google_absl//absl/types:span",
         "@com_google_absl//absl/types:variant",
         "@com_google_protobuf//:protobuf",

eval/compiler/flat_expr_builder.cc

@@ -2660,7 +2660,7 @@ absl::StatusOr<FlatExpression> FlatExprBuilder::CreateExpressionImpl(
 const cel::TypeProvider& FlatExprBuilder::GetTypeProvider() const {
   return use_legacy_type_provider_
              ? static_cast<const cel::TypeProvider&>(
-                   *GetLegacyRuntimeTypeProvider(type_registry_))
+                   GetLegacyRuntimeTypeProvider(type_registry_))
              : GetRuntimeTypeProvider(type_registry_);
 }
 

eval/eval/create_struct_step_test.cc

@@ -58,7 +58,6 @@ namespace {
 
 using ::absl_testing::IsOk;
 using ::absl_testing::StatusIs;
-using ::cel::Expr;
 using ::cel::TypeProvider;
 using ::cel::internal::test::EqualsProto;
 using ::cel::runtime_internal::NewTestingRuntimeEnv;
@@ -200,7 +199,7 @@ TEST_P(CreateCreateStructStepTest, TestEmptyMessageCreation) {
 
   auto adapter = env_->legacy_type_registry.FindTypeAdapter(
       "google.api.expr.runtime.TestMessage");
-  ASSERT_TRUE(adapter.has_value() && adapter->mutation_apis() != nullptr);
+  ASSERT_TRUE(adapter.has_value() && adapter->access_apis() != nullptr);
 
   ASSERT_OK_AND_ASSIGN(auto maybe_type,
                        env_->type_registry.GetComposedTypeProvider().FindType(

eval/public/BUILD

@@ -813,6 +813,7 @@ cc_library(
         "//eval/public/structs:legacy_type_provider",
         "//eval/public/structs:protobuf_descriptor_type_provider",
         "//runtime:type_registry",
+        "@com_google_absl//absl/base",
         "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",

eval/public/cel_type_registry.h

@@ -20,6 +20,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/call_once.h"
 #include "absl/base/nullability.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
@@ -28,6 +29,7 @@
 #include "base/type_provider.h"
 #include "eval/public/structs/legacy_type_adapter.h"
 #include "eval/public/structs/legacy_type_provider.h"
+#include "eval/public/structs/protobuf_descriptor_type_provider.h"
 #include "runtime/type_registry.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/message.h"
@@ -60,7 +62,9 @@ class CelTypeRegistry {
 
   CelTypeRegistry(const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
                   google::protobuf::MessageFactory* absl_nullable message_factory)
-      : modern_type_registry_(descriptor_pool, message_factory) {}
+      : descriptor_pool_(descriptor_pool),
+        message_factory_(message_factory),
+        modern_type_registry_(descriptor_pool, message_factory) {}
 
   ~CelTypeRegistry() = default;
 
@@ -77,8 +81,12 @@ class CelTypeRegistry {
 
   // Get the first registered type provider.
   std::shared_ptr<const LegacyTypeProvider> GetFirstTypeProvider() const {
-    return cel::runtime_internal::GetLegacyRuntimeTypeProvider(
-        modern_type_registry_);
+    absl::call_once(legacy_type_provider_once_, [&]() {
+      this->legacy_type_provider_ = std::make_shared<
+          google::api::expr::runtime::ProtobufDescriptorProvider>(
+          descriptor_pool_, message_factory_);
+    });
+    return legacy_type_provider_;
   }
 
   // Returns the effective type provider that has been configured with the
@@ -136,6 +144,13 @@ class CelTypeRegistry {
   }
 
  private:
+  const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool_;
+  google::protobuf::MessageFactory* absl_nullable message_factory_;
+
+  // Legacy type provider. This is now disconnected from the actual type
+  // resolution, but preserved for legacy clients that used it directly.
+  mutable absl::once_flag legacy_type_provider_once_;
+  mutable std::shared_ptr<LegacyTypeProvider> legacy_type_provider_;
   // Internal modern registry.
   cel::TypeRegistry modern_type_registry_;
 };

eval/public/cel_type_registry_test.cc

@@ -36,7 +36,7 @@ class TestTypeProvider : public LegacyTypeProvider {
       absl::string_view name) const override {
     for (const auto& type : types_) {
       if (name == type) {
-        return LegacyTypeAdapter(/*access=*/nullptr, /*mutation=*/nullptr);
+        return LegacyTypeAdapter(/*access=*/nullptr);
       }
     }
     return std::nullopt;

eval/public/structs/BUILD

@@ -273,7 +273,6 @@ cc_library(
     srcs = ["proto_message_type_adapter.cc"],
     hdrs = ["proto_message_type_adapter.h"],
     deps = [
-        ":cel_proto_wrap_util",
         ":field_access_impl",
         ":legacy_type_adapter",
         ":legacy_type_info_apis",
@@ -311,12 +310,9 @@ cc_test(
         "//common:value_testing",
         "//eval/public:cel_value",
         "//eval/public:message_wrapper",
-        "//eval/public/containers:container_backed_list_impl",
-        "//eval/public/containers:container_backed_map_impl",
         "//eval/public/testing:matchers",
         "//eval/testutil:test_message_cc_proto",
         "//extensions/protobuf:memory_manager",
-        "//internal:proto_matchers",
         "//internal:testing",
         "//runtime:runtime_options",
         "@com_google_absl//absl/status",

eval/public/structs/legacy_type_adapter.h

@@ -18,7 +18,7 @@
 #ifndef THIRD_PARTY_CEL_CPP_EVAL_PUBLIC_STRUCTS_LEGACY_TYPE_ADPATER_H_
 #define THIRD_PARTY_CEL_CPP_EVAL_PUBLIC_STRUCTS_LEGACY_TYPE_ADPATER_H_
 
-#include <cstdint>
+#include <cstddef>
 #include <vector>
 
 #include "absl/status/status.h"
@@ -36,54 +36,6 @@ namespace google::api::expr::runtime {
 class DucktypedMessageAdapter;
 class ProtoMessageTypeAdapter;
 
-// Interface for mutation apis.
-// Note: in the new type system, a type provider represents this by returning
-// a cel::Type and cel::ValueManager for the type.
-class LegacyTypeMutationApis {
- public:
-  virtual ~LegacyTypeMutationApis() = default;
-
-  // Return whether the type defines the given field.
-  // TODO(uncreated-issue/3): This is only used to eagerly fail during the planning
-  // phase. Check if it's safe to remove this behavior and fail at runtime.
-  virtual bool DefinesField(absl::string_view field_name) const = 0;
-
-  // Create a new empty instance of the type.
-  // May return a status if the type is not possible to create.
-  virtual absl::StatusOr<CelValue::MessageWrapper::Builder> NewInstance(
-      cel::MemoryManagerRef memory_manager) const = 0;
-
-  // Normalize special types to a native CEL value after building.
-  // The interpreter guarantees that instance is uniquely owned by the
-  // interpreter, and can be safely mutated.
-  virtual absl::StatusOr<CelValue> AdaptFromWellKnownType(
-      cel::MemoryManagerRef memory_manager,
-      CelValue::MessageWrapper::Builder instance) const = 0;
-
-  // Set field on instance to value.
-  // The interpreter guarantees that instance is uniquely owned by the
-  // interpreter, and can be safely mutated.
-  virtual absl::Status SetField(
-      absl::string_view field_name, const CelValue& value,
-      cel::MemoryManagerRef memory_manager,
-      CelValue::MessageWrapper::Builder& instance) const = 0;
-
-  virtual absl::Status SetFieldByNumber(
-      int64_t field_number [[maybe_unused]],
-      const CelValue& value [[maybe_unused]],
-      cel::MemoryManagerRef memory_manager [[maybe_unused]],
-      CelValue::MessageWrapper::Builder& instance [[maybe_unused]]) const {
-    return absl::UnimplementedError("SetFieldByNumber is not yet implemented");
-  }
-
- private:
-  // This class should only be implemented by CEL. Custom structs are only
-  // supported using the cel::Value APIs.
-  friend class ProtoMessageTypeAdapter;
-
-  LegacyTypeMutationApis() = default;
-};
-
 // Interface for access apis.
 // Note: in new type system this is integrated into the StructValue (via
 // dynamic dispatch to concrete implementations).
@@ -162,9 +114,6 @@ class LegacyTypeAccessApis {
 // Type information about a legacy Struct type.
 // Provides methods to the interpreter for interacting with a custom type.
 //
-// mutation_apis() provide equivalent behavior to a cel::Type and
-// cel::ValueManager (resolved from a type name).
-//
 // access_apis() provide equivalent behavior to cel::StructValue accessors
 // (virtual dispatch to a concrete implementation for accessing underlying
 // values).
@@ -174,21 +123,18 @@ class LegacyTypeAccessApis {
 // the type provider that returned this object.
 class LegacyTypeAdapter {
  public:
-  LegacyTypeAdapter(const LegacyTypeAccessApis* access,
-                    const LegacyTypeMutationApis* mutation)
-      : access_apis_(access), mutation_apis_(mutation) {}
+  explicit LegacyTypeAdapter(const LegacyTypeAccessApis* access)
+      : access_apis_(access) {}
+  // Temporary constructor to support fakes in client tests.
+  LegacyTypeAdapter(const LegacyTypeAccessApis* access, std::nullptr_t)
+      : access_apis_(access) {}
 
   // Apis for access for the represented type.
   // If null, access is not supported (this is an opaque type).
-  const LegacyTypeAccessApis* access_apis() { return access_apis_; }
-
-  // Apis for mutation for the represented type.
-  // If null, mutation is not supported (this type cannot be created).
-  const LegacyTypeMutationApis* mutation_apis() { return mutation_apis_; }
+  const LegacyTypeAccessApis* access_apis() const { return access_apis_; }
 
  private:
   const LegacyTypeAccessApis* access_apis_;
-  const LegacyTypeMutationApis* mutation_apis_;
 };
 
 }  // namespace google::api::expr::runtime

eval/public/structs/legacy_type_adapter_test.cc

@@ -23,10 +23,9 @@ namespace {
 
 TEST(LegacyTypeAdapter, Basic) {
   ProtoMessageTypeAdapter adapter(TestMessage::descriptor(), nullptr);
-  LegacyTypeAdapter type_adapter(&adapter, &adapter);
+  LegacyTypeAdapter type_adapter(&adapter);
 
   EXPECT_EQ(type_adapter.access_apis(), &adapter);
-  EXPECT_EQ(type_adapter.mutation_apis(), &adapter);
 }
 
 }  // namespace

eval/public/structs/legacy_type_info_apis.h

@@ -27,7 +27,6 @@ namespace google::api::expr::runtime {
 
 // Forward declared to resolve cyclic dependency.
 class LegacyTypeAccessApis;
-class LegacyTypeMutationApis;
 
 // Forward declare permitted subclasses.
 class DucktypedMessageAdapter;
@@ -40,8 +39,8 @@ class TrivialTypeInfo;
 // Provides ability to obtain field access apis, type info, and debug
 // representation of a message.
 //
-// The message parameter may wrap a nullptr to request generic accessors /
-// mutators for the TypeInfo instance if it is available.
+// The message parameter may wrap a nullptr to request generic accessors for
+// the TypeInfo instance if it is available.
 //
 // This is implemented as a separate class from LegacyTypeAccessApis to resolve
 // cyclic dependency between CelValue (which needs to access these apis to
@@ -87,17 +86,6 @@ class LegacyTypeInfoApis {
   virtual const LegacyTypeAccessApis* GetAccessApis(
       const MessageWrapper& wrapped_message) const = 0;
 
-  // Return a pointer to the wrapped message's mutation api implementation.
-  //
-  // The CEL interpreter assumes that the returned pointer is owned externally
-  // and will outlive any CelValues created by the interpreter.
-  //
-  // Nullptr signals that the value does not provide mutation apis.
-  virtual const LegacyTypeMutationApis* GetMutationApis(
-      const MessageWrapper& wrapped_message [[maybe_unused]]) const {
-    return nullptr;
-  }
-
   // Return a description of the underlying field if defined.
   //
   // The underlying string is expected to remain valid as long as the