Update RuntimeBuilder to accept std::shared_ptr<const proto2::DescriptorPool> to match type checker

PiperOrigin-RevId: 690674918

Author: jcking

checker/BUILD

@@ -90,6 +90,7 @@ cc_library(
         "//checker/internal:type_checker_impl",
         "//common:decl",
         "//common:type",
+        "//internal:noop_delete",
         "//internal:status_macros",
         "//internal:well_known_types",
         "//parser:macro",

checker/type_checker_builder.cc

@@ -34,6 +34,7 @@
 #include "common/decl.h"
 #include "common/type.h"
 #include "common/type_introspector.h"
+#include "internal/noop_delete.h"
 #include "internal/status_macros.h"
 #include "internal/well_known_types.h"
 #include "parser/macro.h"
@@ -89,7 +90,7 @@ absl::StatusOr<TypeCheckerBuilder> CreateTypeCheckerBuilder(
   return CreateTypeCheckerBuilder(
       std::shared_ptr<const google::protobuf::DescriptorPool>(
           descriptor_pool,
-          [](absl::Nullable<const google::protobuf::DescriptorPool*>) {}),
+          internal::NoopDeleteFor<const google::protobuf::DescriptorPool>()),
       options);
 }
 

internal/BUILD

@@ -580,6 +580,7 @@ cc_library(
     hdrs = ["testing_descriptor_pool.h"],
     textual_hdrs = [":testing_descriptor_set_embed"],
     deps = [
+        ":noop_delete",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/base:no_destructor",
         "@com_google_absl//absl/base:nullability",
@@ -829,3 +830,9 @@ cc_library(
     hdrs = ["protobuf_runtime_version.h"],
     deps = ["@com_google_protobuf//:protobuf"],
 )
+
+cc_library(
+    name = "noop_delete",
+    hdrs = ["noop_delete.h"],
+    deps = ["@com_google_absl//absl/base:nullability"],
+)

internal/noop_delete.h

@@ -0,0 +1,53 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef THIRD_PARTY_CEL_CPP_INTERNAL_NOOP_DELETE_H_
+#define THIRD_PARTY_CEL_CPP_INTERNAL_NOOP_DELETE_H_
+
+#include <type_traits>
+
+#include "absl/base/nullability.h"
+
+namespace cel::internal {
+
+// Like `std::default_delete`, except it does nothing.
+template <typename T>
+struct NoopDelete {
+  static_assert(!std::is_function<T>::value,
+                "NoopDelete cannot be instantiated for function types");
+
+  constexpr NoopDelete() noexcept = default;
+  constexpr NoopDelete(const NoopDelete<T>&) noexcept = default;
+
+  template <
+      typename U,
+      typename = std::enable_if_t<std::conjunction_v<
+          std::negation<std::is_same<T, U>>, std::is_convertible<U*, T*>>>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr NoopDelete(const NoopDelete<U>&) noexcept {}
+
+  constexpr void operator()(absl::Nullable<T*>) const noexcept {
+    static_assert(sizeof(T) >= 0, "cannot delete an incomplete type");
+    static_assert(!std::is_void<T>::value, "cannot delete an incomplete type");
+  }
+};
+
+template <typename T>
+inline constexpr NoopDelete<T> NoopDeleteFor() noexcept {
+  return NoopDelete<T>{};
+}
+
+}  // namespace cel::internal
+
+#endif  // THIRD_PARTY_CEL_CPP_INTERNAL_NOOP_DELETE_H_

internal/testing_descriptor_pool.cc

@@ -23,6 +23,7 @@
 #include "absl/base/no_destructor.h"
 #include "absl/base/nullability.h"
 #include "absl/log/absl_check.h"
+#include "internal/noop_delete.h"
 #include "google/protobuf/descriptor.h"
 
 namespace cel::internal {
@@ -54,7 +55,7 @@ GetSharedTestingDescriptorPool() {
   static const absl::NoDestructor<
       absl::Nonnull<std::shared_ptr<const google::protobuf::DescriptorPool>>>
       instance(GetTestingDescriptorPool(),
-               [](absl::Nullable<const google::protobuf::DescriptorPool*>) {});
+               internal::NoopDeleteFor<const google::protobuf::DescriptorPool>());
   return *instance;
 }
 

internal/well_known_types.cc

@@ -1762,6 +1762,18 @@ absl::Status Reflection::Initialize(absl::Nonnull<const DescriptorPool*> pool) {
   return absl::OkStatus();
 }
 
+bool Reflection::IsInitialized() const {
+  // Check that everything is initialized except field mask, which is optional.
+  return NullValue().IsInitialized() && BoolValue().IsInitialized() &&
+         Int32Value().IsInitialized() && Int64Value().IsInitialized() &&
+         UInt32Value().IsInitialized() && UInt64Value().IsInitialized() &&
+         FloatValue().IsInitialized() && DoubleValue().IsInitialized() &&
+         BytesValue().IsInitialized() && StringValue().IsInitialized() &&
+         Any().IsInitialized() && Duration().IsInitialized() &&
+         Timestamp().IsInitialized() && Value().IsInitialized() &&
+         ListValue().IsInitialized() && Struct().IsInitialized();
+}
+
 namespace {
 
 // AdaptListValue verifies the message is the well known type

internal/well_known_types.h

@@ -1391,6 +1391,8 @@ class Reflection final {
 
   absl::Status Initialize(absl::Nonnull<const google::protobuf::DescriptorPool*> pool);
 
+  bool IsInitialized() const;
+
   // At the moment we only use this class for verifying well known types in
   // descriptor pools. We could eagerly initialize it and cache it somewhere to
   // make things faster.

runtime/BUILD

@@ -213,10 +213,12 @@ cc_library(
     deps = [
         ":runtime_builder",
         ":runtime_options",
+        "//internal:noop_delete",
         "//internal:status_macros",
         "//runtime/internal:runtime_impl",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/base:nullability",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/status:statusor",
         "@com_google_protobuf//:protobuf",
     ],
@@ -231,9 +233,11 @@ cc_library(
         ":runtime_builder_factory",
         ":runtime_options",
         ":standard_functions",
+        "//internal:noop_delete",
         "//internal:status_macros",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/base:nullability",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/status:statusor",
         "@com_google_protobuf//:protobuf",
     ],

runtime/internal/BUILD

@@ -69,8 +69,11 @@ cc_library(
         "//runtime:function_registry",
         "//runtime:runtime_options",
         "//runtime:type_registry",
+        "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/base:nullability",
+        "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/status:statusor",
+        "@com_google_protobuf//:protobuf",
     ],
 )
 

runtime/internal/runtime_impl.h

@@ -16,7 +16,11 @@
 #define THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_RUNTIME_IMPL_H_
 
 #include <memory>
+#include <utility>
 
+#include "absl/base/attributes.h"
+#include "absl/base/nullability.h"
+#include "absl/log/absl_check.h"
 #include "absl/status/statusor.h"
 #include "base/ast.h"
 #include "base/type_provider.h"
@@ -27,21 +31,28 @@
 #include "runtime/runtime.h"
 #include "runtime/runtime_options.h"
 #include "runtime/type_registry.h"
+#include "google/protobuf/descriptor.h"
 
 namespace cel::runtime_internal {
 
 class RuntimeImpl : public Runtime {
  public:
   struct Environment {
+    ABSL_ATTRIBUTE_UNUSED
+    absl::Nonnull<std::shared_ptr<const google::protobuf::DescriptorPool>>
+        descriptor_pool;
     TypeRegistry type_registry;
     FunctionRegistry function_registry;
     well_known_types::Reflection well_known_types;
   };
 
-  explicit RuntimeImpl(const RuntimeOptions& options)
-      : environment_(std::make_shared<Environment>()),
+  RuntimeImpl(absl::Nonnull<std::shared_ptr<Environment>> environment,
+              const RuntimeOptions& options)
+      : environment_(std::move(environment)),
         expr_builder_(environment_->function_registry,
-                      environment_->type_registry, options) {}
+                      environment_->type_registry, options) {
+    ABSL_DCHECK(environment_->well_known_types.IsInitialized());
+  }
 
   TypeRegistry& type_registry() { return environment_->type_registry; }
   const TypeRegistry& type_registry() const {
@@ -55,9 +66,6 @@ class RuntimeImpl : public Runtime {
     return environment_->function_registry;
   }
 
-  well_known_types::Reflection& well_known_types() {
-    return environment_->well_known_types;
-  }
   const well_known_types::Reflection& well_known_types() const {
     return environment_->well_known_types;
   }