protovalidate 0.1.0.beta1

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/convert_constant.cc

@@ -0,0 +1,78 @@
+// Copyright 2023 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.
+
+#include "runtime/internal/convert_constant.h"
+
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/time/time.h"
+#include "absl/types/variant.h"
+#include "common/allocator.h"
+#include "common/constant.h"
+#include "common/value.h"
+#include "eval/internal/errors.h"
+
+namespace cel::runtime_internal {
+namespace {
+using ::cel::Constant;
+
+struct ConvertVisitor {
+  Allocator<> allocator;
+
+  absl::StatusOr<cel::Value> operator()(std::monostate) {
+    return absl::InvalidArgumentError("unspecified constant");
+  }
+  absl::StatusOr<cel::Value> operator()(std::nullptr_t) { return NullValue(); }
+  absl::StatusOr<cel::Value> operator()(bool value) { return BoolValue(value); }
+  absl::StatusOr<cel::Value> operator()(int64_t value) {
+    return IntValue(value);
+  }
+  absl::StatusOr<cel::Value> operator()(uint64_t value) {
+    return UintValue(value);
+  }
+  absl::StatusOr<cel::Value> operator()(double value) {
+    return DoubleValue(value);
+  }
+  absl::StatusOr<cel::Value> operator()(const cel::StringConstant& value) {
+    return StringValue(allocator, value);
+  }
+  absl::StatusOr<cel::Value> operator()(const cel::BytesConstant& value) {
+    return BytesValue(allocator, value);
+  }
+  absl::StatusOr<cel::Value> operator()(const absl::Duration duration) {
+    if (duration >= kDurationHigh || duration <= kDurationLow) {
+      return ErrorValue(*DurationOverflowError());
+    }
+    return UnsafeDurationValue(duration);
+  }
+  absl::StatusOr<cel::Value> operator()(const absl::Time timestamp) {
+    return UnsafeTimestampValue(timestamp);
+  }
+};
+
+}  // namespace
+
+// Converts an Ast constant into a runtime value, managed according to the
+// given value factory.
+//
+// A status maybe returned if value creation fails.
+absl::StatusOr<Value> ConvertConstant(const Constant& constant,
+                                      Allocator<> allocator) {
+  return absl::visit(ConvertVisitor{allocator}, constant.constant_kind());
+}
+
+}  // namespace cel::runtime_internal

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/convert_constant.h

@@ -0,0 +1,39 @@
+// Copyright 2023 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_RUNTIME_INTERNAL_CONVERT_CONSTANT_H_
+#define THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_CONVERT_CONSTANT_H_
+
+#include "absl/status/statusor.h"
+#include "common/allocator.h"
+#include "common/ast.h"
+#include "common/value.h"
+
+namespace cel::runtime_internal {
+
+// Adapt AST constant to a Value.
+//
+// Underlying data is copied for string types to keep the program independent
+// from the input AST.
+//
+// The evaluator assumes most ast constants are valid so unchecked ValueManager
+// methods are used.
+//
+// A status may still be returned if value creation fails according to
+// value_factory's policy.
+absl::StatusOr<Value> ConvertConstant(const Constant& constant,
+                                      Allocator<> allocator);
+
+}  // namespace cel::runtime_internal
+
+#endif  // THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_CONVERT_CONSTANT_H_

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/errors.cc

@@ -0,0 +1,69 @@
+// Copyright 2022 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.
+#include "runtime/internal/errors.h"
+
+#include "absl/status/status.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+namespace cel::runtime_internal {
+
+const absl::Status* DurationOverflowError() {
+  static const auto* const kDurationOverflow = new absl::Status(
+      absl::StatusCode::kInvalidArgument, "Duration is out of range");
+  return kDurationOverflow;
+}
+
+absl::Status CreateNoSuchKeyError(absl::string_view key) {
+  return absl::NotFoundError(absl::StrCat(kErrNoSuchKey, " : ", key));
+}
+
+absl::Status CreateNoMatchingOverloadError(absl::string_view fn) {
+  return absl::UnknownError(
+      absl::StrCat(kErrNoMatchingOverload, fn.empty() ? "" : " : ", fn));
+}
+
+absl::Status CreateNoSuchFieldError(absl::string_view field) {
+  return absl::Status(
+      absl::StatusCode::kNotFound,
+      absl::StrCat(kErrNoSuchField, field.empty() ? "" : " : ", field));
+}
+
+absl::Status CreateMissingAttributeError(
+    absl::string_view missing_attribute_path) {
+  absl::Status result = absl::InvalidArgumentError(
+      absl::StrCat(kErrMissingAttribute, missing_attribute_path));
+  result.SetPayload(kPayloadUrlMissingAttributePath,
+                    absl::Cord(missing_attribute_path));
+  return result;
+}
+
+absl::Status CreateInvalidMapKeyTypeError(absl::string_view key_type) {
+  return absl::InvalidArgumentError(
+      absl::StrCat("Invalid map key type: '", key_type, "'"));
+}
+
+absl::Status CreateUnknownFunctionResultError(absl::string_view help_message) {
+  absl::Status result = absl::UnavailableError(
+      absl::StrCat("Unknown function result: ", help_message));
+  result.SetPayload(kPayloadUrlUnknownFunctionResult, absl::Cord("true"));
+  return result;
+}
+
+absl::Status CreateError(absl::string_view message, absl::StatusCode code) {
+  return absl::Status(code, message);
+}
+
+}  // namespace cel::runtime_internal

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/errors.h

@@ -0,0 +1,71 @@
+// Copyright 2022 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.
+//
+// Factories and constants for well-known CEL errors.
+#ifndef THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_ERRORS_H_
+#define THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_ERRORS_H_
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+
+namespace cel::runtime_internal {
+
+constexpr absl::string_view kErrNoMatchingOverload =
+    "No matching overloads found";
+constexpr absl::string_view kErrNoSuchField = "no_such_field";
+constexpr absl::string_view kErrNoSuchKey = "Key not found in map";
+// Error name for MissingAttributeError indicating that evaluation has
+// accessed an attribute whose value is undefined. go/terminal-unknown
+constexpr absl::string_view kErrMissingAttribute = "MissingAttributeError: ";
+constexpr absl::string_view kPayloadUrlMissingAttributePath =
+    "missing_attribute_path";
+constexpr absl::string_view kPayloadUrlUnknownFunctionResult =
+    "cel_is_unknown_function_result";
+
+// Exclusive bounds for valid duration values.
+constexpr absl::Duration kDurationHigh = absl::Seconds(315576000001);
+constexpr absl::Duration kDurationLow = absl::Seconds(-315576000001);
+
+const absl::Status* DurationOverflowError();
+
+// At runtime, no matching overload could be found for a function invocation.
+absl::Status CreateNoMatchingOverloadError(absl::string_view fn);
+
+// No such field for struct access.
+absl::Status CreateNoSuchFieldError(absl::string_view field);
+
+// No such key for map access.
+absl::Status CreateNoSuchKeyError(absl::string_view key);
+
+// Invalid key type used for map index.
+absl::Status CreateInvalidMapKeyTypeError(absl::string_view key_type);
+
+// A missing attribute was accessed. Attributes may be declared as missing to
+// they are not well defined at evaluation time.
+absl::Status CreateMissingAttributeError(
+    absl::string_view missing_attribute_path);
+
+// Function result is unknown. The evaluator may convert this to an
+// UnknownValue if enabled.
+absl::Status CreateUnknownFunctionResultError(absl::string_view help_message);
+
+// The default error type uses absl::StatusCode::kUnknown. In general, a more
+// specific error should be used.
+absl::Status CreateError(absl::string_view message,
+                         absl::StatusCode code = absl::StatusCode::kUnknown);
+
+}  // namespace cel::runtime_internal
+
+#endif  // THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_ERRORS_H_

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/function_adapter.h

@@ -0,0 +1,232 @@
+// Copyright 2023 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.
+//
+// Definitions for implementation details of the function adapter utility.
+
+#ifndef THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_FUNCTION_ADAPTER_H_
+#define THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_FUNCTION_ADAPTER_H_
+
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/time/time.h"
+#include "common/casting.h"
+#include "common/kind.h"
+#include "common/value.h"
+
+namespace cel::runtime_internal {
+
+// Helper for triggering static asserts in an unspecialized template overload.
+template <typename T>
+struct UnhandledType : std::false_type {};
+
+// Adapts the type param Type to the appropriate Kind.
+// A static assertion fails if the provided type does not map to a cel::Value
+// kind.
+template <typename Type>
+constexpr Kind AdaptedKind() {
+  static_assert(UnhandledType<Type>::value,
+                "Unsupported primitive type to cel::Kind conversion");
+  return Kind::kNotForUseWithExhaustiveSwitchStatements;
+}
+
+template <>
+constexpr Kind AdaptedKind<int64_t>() {
+  return Kind::kInt64;
+}
+
+template <>
+constexpr Kind AdaptedKind<uint64_t>() {
+  return Kind::kUint64;
+}
+
+template <>
+constexpr Kind AdaptedKind<double>() {
+  return Kind::kDouble;
+}
+
+template <>
+constexpr Kind AdaptedKind<bool>() {
+  return Kind::kBool;
+}
+
+template <>
+constexpr Kind AdaptedKind<absl::Time>() {
+  return Kind::kTimestamp;
+}
+
+template <>
+constexpr Kind AdaptedKind<absl::Duration>() {
+  return Kind::kDuration;
+}
+
+// Value types without a generic C++ type representation can be referenced by
+// cref or value of the cel::*Value type.
+#define VALUE_ADAPTED_KIND_OVL(value_type, kind)    \
+  template <>                                       \
+  constexpr Kind AdaptedKind<const value_type&>() { \
+    return kind;                                    \
+  }                                                 \
+                                                    \
+  template <>                                       \
+  constexpr Kind AdaptedKind<value_type>() {        \
+    return kind;                                    \
+  }
+
+VALUE_ADAPTED_KIND_OVL(Value, Kind::kAny);
+VALUE_ADAPTED_KIND_OVL(StringValue, Kind::kString);
+VALUE_ADAPTED_KIND_OVL(BytesValue, Kind::kBytes);
+VALUE_ADAPTED_KIND_OVL(StructValue, Kind::kStruct);
+VALUE_ADAPTED_KIND_OVL(MapValue, Kind::kMap);
+VALUE_ADAPTED_KIND_OVL(ListValue, Kind::kList);
+VALUE_ADAPTED_KIND_OVL(NullValue, Kind::kNullType);
+VALUE_ADAPTED_KIND_OVL(OpaqueValue, Kind::kOpaque);
+VALUE_ADAPTED_KIND_OVL(TypeValue, Kind::kType);
+
+#undef VALUE_ADAPTED_KIND_OVL
+
+// Adapt a Value to its corresponding argument type in a wrapped c++
+// function.
+struct ValueToAdaptedVisitor {
+  absl::Status operator()(int64_t* out) const {
+    if (!input.IsInt()) {
+      return absl::InvalidArgumentError("expected int value");
+    }
+    *out = input.GetInt().NativeValue();
+    return absl::OkStatus();
+  }
+
+  absl::Status operator()(uint64_t* out) const {
+    if (!input.IsUint()) {
+      return absl::InvalidArgumentError("expected uint value");
+    }
+    *out = input.GetUint().NativeValue();
+    return absl::OkStatus();
+  }
+
+  absl::Status operator()(double* out) const {
+    if (!input.IsDouble()) {
+      return absl::InvalidArgumentError("expected double value");
+    }
+    *out = input.GetDouble().NativeValue();
+    return absl::OkStatus();
+  }
+
+  absl::Status operator()(bool* out) const {
+    if (!input.IsBool()) {
+      return absl::InvalidArgumentError("expected bool value");
+    }
+    *out = input.GetBool().NativeValue();
+    return absl::OkStatus();
+  }
+
+  absl::Status operator()(absl::Time* out) const {
+    if (!input.IsTimestamp()) {
+      return absl::InvalidArgumentError("expected timestamp value");
+    }
+    *out = input.GetTimestamp().ToTime();
+    return absl::OkStatus();
+  }
+
+  absl::Status operator()(absl::Duration* out) const {
+    if (!input.IsDuration()) {
+      return absl::InvalidArgumentError("expected duration value");
+    }
+    *out = input.GetDuration().ToDuration();
+    return absl::OkStatus();
+  }
+
+  absl::Status operator()(Value* out) const {
+    *out = input;
+    return absl::OkStatus();
+  }
+
+  absl::Status operator()(const Value** out) const {
+    *out = &input;
+    return absl::OkStatus();
+  }
+
+  template <typename T>
+  absl::Status operator()(T* out) const {
+    if (!InstanceOf<std::remove_const_t<T>>(input)) {
+      return absl::InvalidArgumentError(
+          absl::StrCat("expected ", ValueKindToString(T::kKind), " value"));
+    }
+    *out = Cast<std::remove_const_t<T>>(input);
+    return absl::OkStatus();
+  }
+
+  template <typename T>
+  absl::Status operator()(T** out) const {
+    if (!InstanceOf<std::remove_const_t<T>>(input)) {
+      return absl::InvalidArgumentError(
+          absl::StrCat("expected ", ValueKindToString(T::kKind), " value"));
+    }
+    static_assert(std::is_lvalue_reference_v<
+                      decltype(Cast<std::remove_const_t<T>>(input))>,
+                  "expected l-value reference return type for Cast.");
+    *out = &Cast<std::remove_const_t<T>>(input);
+    return absl::OkStatus();
+  }
+
+  const Value& input;
+};
+
+// Adapts the return value of a wrapped C++ function to its corresponding
+// Value representation.
+struct AdaptedToValueVisitor {
+  absl::StatusOr<Value> operator()(int64_t in) { return IntValue(in); }
+
+  absl::StatusOr<Value> operator()(uint64_t in) { return UintValue(in); }
+
+  absl::StatusOr<Value> operator()(double in) { return DoubleValue(in); }
+
+  absl::StatusOr<Value> operator()(bool in) { return BoolValue(in); }
+
+  absl::StatusOr<Value> operator()(absl::Time in) {
+    // Type matching may have already occurred. It's too late to change up the
+    // type and return an error.
+    return TimestampValue(in);
+  }
+
+  absl::StatusOr<Value> operator()(absl::Duration in) {
+    // Type matching may have already occurred. It's too late to change up the
+    // type and return an error.
+    return DurationValue(in);
+  }
+
+  absl::StatusOr<Value> operator()(Value in) { return in; }
+
+  template <typename T>
+  absl::StatusOr<Value> operator()(T in) {
+    return in;
+  }
+
+  // Special case for StatusOr<T> return value -- wrap the underlying value if
+  // present, otherwise return the status.
+  template <typename T>
+  absl::StatusOr<Value> operator()(absl::StatusOr<T> wrapped) {
+    if (!wrapped.ok()) {
+      return std::move(wrapped).status();
+    }
+    return this->operator()(std::move(wrapped).value());
+  }
+};
+
+}  // namespace cel::runtime_internal
+
+#endif  // THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_FUNCTION_ADAPTER_H_

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/issue_collector.h

@@ -0,0 +1,64 @@
+// Copyright 2023 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_RUNTIME_INTERNAL_ISSUE_COLLECTOR_H_
+#define THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_ISSUE_COLLECTOR_H_
+
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/types/span.h"
+#include "runtime/runtime_issue.h"
+
+namespace cel::runtime_internal {
+
+// IssueCollector collects issues and reports absl::Status according to the
+// configured severity limit.
+class IssueCollector {
+ public:
+  // Args:
+  //  severity: inclusive limit for issues to return as non-ok absl::Status.
+  explicit IssueCollector(RuntimeIssue::Severity severity_limit)
+      : severity_limit_(severity_limit) {}
+
+  // move-only.
+  IssueCollector(const IssueCollector&) = delete;
+  IssueCollector& operator=(const IssueCollector&) = delete;
+  IssueCollector(IssueCollector&&) = default;
+  IssueCollector& operator=(IssueCollector&&) = default;
+
+  // Collect an Issue.
+  // Returns a status according to the IssueCollector's policy and the given
+  // Issue.
+  // The Issue is always added to issues, regardless of whether AddIssue returns
+  // a non-ok status.
+  absl::Status AddIssue(RuntimeIssue issue) {
+    issues_.push_back(std::move(issue));
+    if (issues_.back().severity() >= severity_limit_) {
+      return issues_.back().ToStatus();
+    }
+    return absl::OkStatus();
+  }
+
+  absl::Span<const RuntimeIssue> issues() const { return issues_; }
+  std::vector<RuntimeIssue> ExtractIssues() { return std::move(issues_); }
+
+ private:
+  RuntimeIssue::Severity severity_limit_;
+  std::vector<RuntimeIssue> issues_;
+};
+
+}  // namespace cel::runtime_internal
+
+#endif  // THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_ISSUE_COLLECTOR_H_

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/legacy_runtime_type_provider.h

@@ -0,0 +1,37 @@
+// 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_RUNTIME_INTERNAL_LEGACY_RUNTIME_TYPE_PROVIDER_H_
+#define THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_LEGACY_RUNTIME_TYPE_PROVIDER_H_
+
+#include "absl/base/nullability.h"
+#include "eval/public/structs/protobuf_descriptor_type_provider.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
+
+namespace cel::runtime_internal {
+
+class LegacyRuntimeTypeProvider final
+    : public google::api::expr::runtime::ProtobufDescriptorProvider {
+ public:
+  LegacyRuntimeTypeProvider(
+      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+      google::protobuf::MessageFactory* absl_nullable message_factory)
+      : google::api::expr::runtime::ProtobufDescriptorProvider(
+            descriptor_pool, message_factory) {}
+};
+
+}  // namespace cel::runtime_internal
+
+#endif  // THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_LEGACY_RUNTIME_TYPE_PROVIDER_H_

data/ext/protovalidate/sys/third_party/cel-cpp/runtime/internal/runtime_env.cc

@@ -0,0 +1,73 @@
+// 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.
+
+#include "runtime/internal/runtime_env.h"
+
+#include <atomic>
+#include <memory>
+#include <utility>
+
+#include "absl/base/nullability.h"
+#include "absl/synchronization/mutex.h"
+#include "internal/noop_delete.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/dynamic_message.h"
+#include "google/protobuf/message.h"
+
+namespace cel::runtime_internal {
+
+RuntimeEnv::KeepAlives::~KeepAlives() {
+  while (!deque.empty()) {
+    deque.pop_back();
+  }
+}
+
+google::protobuf::MessageFactory* absl_nonnull RuntimeEnv::MutableMessageFactory() const {
+  google::protobuf::MessageFactory* absl_nullable shared_message_factory =
+      message_factory_ptr.load(std::memory_order_relaxed);
+  if (shared_message_factory != nullptr) {
+    return shared_message_factory;
+  }
+  absl::MutexLock lock(message_factory_mutex);
+  shared_message_factory = message_factory_ptr.load(std::memory_order_relaxed);
+  if (shared_message_factory == nullptr) {
+    if (descriptor_pool.get() == google::protobuf::DescriptorPool::generated_pool()) {
+      // Using the generated descriptor pool, just use the generated message
+      // factory.
+      message_factory = std::shared_ptr<google::protobuf::MessageFactory>(
+          google::protobuf::MessageFactory::generated_factory(),
+          internal::NoopDeleteFor<google::protobuf::MessageFactory>());
+    } else {
+      auto dynamic_message_factory =
+          std::make_shared<google::protobuf::DynamicMessageFactory>();
+      // Ensure we do not delegate to the generated factory, if the default
+      // every changes. We prefer being hermetic.
+      dynamic_message_factory->SetDelegateToGeneratedFactory(false);
+      message_factory = std::move(dynamic_message_factory);
+    }
+    shared_message_factory = message_factory.get();
+    message_factory_ptr.store(shared_message_factory,
+                              std::memory_order_seq_cst);
+  }
+  return shared_message_factory;
+}
+
+void RuntimeEnv::KeepAlive(std::shared_ptr<const void> keep_alive) {
+  if (keep_alive == nullptr) {
+    return;
+  }
+  keep_alives.deque.push_back(std::move(keep_alive));
+}
+
+}  // namespace cel::runtime_internal