Cleanup Legacy values

PiperOrigin-RevId: 732932448

Author: jcking

common/BUILD

@@ -594,7 +594,6 @@ cc_library(
         ":unknown",
         ":value_kind",
         "//base:attributes",
-        "//base/internal:message_wrapper",
         "//common/internal:byte_string",
         "//common/internal:reference_count",
         "//eval/internal:cel_value_equal",

common/legacy_value.cc

@@ -79,12 +79,12 @@ inline DoubleValue CreateDoubleValue(double value) {
 
 inline ListValue CreateLegacyListValue(
     const google::api::expr::runtime::CelList* value) {
-  return common_internal::LegacyListValue{reinterpret_cast<uintptr_t>(value)};
+  return common_internal::LegacyListValue(value);
 }
 
 inline MapValue CreateLegacyMapValue(
     const google::api::expr::runtime::CelMap* value) {
-  return common_internal::LegacyMapValue{reinterpret_cast<uintptr_t>(value)};
+  return common_internal::LegacyMapValue(value);
 }
 
 inline Value CreateDurationValue(absl::Duration value, bool unchecked = false) {

common/legacy_value.h

@@ -14,8 +14,6 @@
 
 #include "common/values/legacy_list_value.h"
 
-#include <cstdint>
-
 #include "absl/base/nullability.h"
 #include "absl/log/absl_check.h"
 #include "absl/status/status.h"
@@ -62,15 +60,15 @@ absl::optional<LegacyListValue> AsLegacyListValue(const Value& value) {
   if (auto custom_list_value = value.AsCustomList(); custom_list_value) {
     NativeTypeId native_type_id = NativeTypeId::Of(*custom_list_value);
     if (native_type_id == NativeTypeId::For<CompatListValue>()) {
-      return LegacyListValue(reinterpret_cast<uintptr_t>(
+      return LegacyListValue(
           static_cast<const google::api::expr::runtime::CelList*>(
               cel::internal::down_cast<const CompatListValue*>(
-                  (*custom_list_value).operator->()))));
+                  (*custom_list_value).operator->())));
     } else if (native_type_id == NativeTypeId::For<MutableCompatListValue>()) {
-      return LegacyListValue(reinterpret_cast<uintptr_t>(
+      return LegacyListValue(
           static_cast<const google::api::expr::runtime::CelList*>(
               cel::internal::down_cast<const MutableCompatListValue*>(
-                  (*custom_list_value).operator->()))));
+                  (*custom_list_value).operator->())));
     }
   }
   return absl::nullopt;

common/values/legacy_list_value.cc

@@ -19,7 +19,6 @@
 #define THIRD_PARTY_CEL_CPP_COMMON_VALUES_LEGACY_LIST_VALUE_H_
 
 #include <cstddef>
-#include <cstdint>
 #include <ostream>
 #include <string>
 
@@ -36,6 +35,10 @@
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/message.h"
 
+namespace google::api::expr::runtime {
+class CelList;
+}
+
 namespace cel {
 
 class TypeManager;
@@ -50,8 +53,9 @@ class LegacyListValue final
  public:
   static constexpr ValueKind kKind = ValueKind::kList;
 
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  explicit LegacyListValue(uintptr_t impl) : impl_(impl) {}
+  explicit LegacyListValue(
+      absl::NullabilityUnknown<const google::api::expr::runtime::CelList*> impl)
+      : impl_(impl) {}
 
   // By default, this creates an empty list whose type is `list(dyn)`. Unless
   // you can help it, you should use a more specific typed list value.
@@ -127,24 +131,23 @@ class LegacyListValue final
       absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const;
   using ListValueMixin::Contains;
 
-  void swap(LegacyListValue& other) noexcept {
-    using std::swap;
-    swap(impl_, other.impl_);
+  absl::NullabilityUnknown<const google::api::expr::runtime::CelList*>
+  cel_list() const {
+    return impl_;
   }
 
-  uintptr_t NativeValue() const { return impl_; }
+  friend void swap(LegacyListValue& lhs, LegacyListValue& rhs) noexcept {
+    using std::swap;
+    swap(lhs.impl_, rhs.impl_);
+  }
 
  private:
   friend class common_internal::ValueMixin<LegacyListValue>;
   friend class common_internal::ListValueMixin<LegacyListValue>;
 
-  uintptr_t impl_;
+  absl::NullabilityUnknown<const google::api::expr::runtime::CelList*> impl_;
 };
 
-inline void swap(LegacyListValue& lhs, LegacyListValue& rhs) noexcept {
-  lhs.swap(rhs);
-}
-
 inline std::ostream& operator<<(std::ostream& out,
                                 const LegacyListValue& type) {
   return out << type.DebugString();

common/values/legacy_list_value.h

@@ -14,8 +14,6 @@
 
 #include "common/values/legacy_map_value.h"
 
-#include <cstdint>
-
 #include "absl/base/nullability.h"
 #include "absl/log/absl_check.h"
 #include "absl/status/status.h"
@@ -62,15 +60,15 @@ absl::optional<LegacyMapValue> AsLegacyMapValue(const Value& value) {
   if (auto custom_map_value = value.AsCustomMap(); custom_map_value) {
     NativeTypeId native_type_id = NativeTypeId::Of(*custom_map_value);
     if (native_type_id == NativeTypeId::For<CompatMapValue>()) {
-      return LegacyMapValue(reinterpret_cast<uintptr_t>(
+      return LegacyMapValue(
           static_cast<const google::api::expr::runtime::CelMap*>(
               cel::internal::down_cast<const CompatMapValue*>(
-                  (*custom_map_value).operator->()))));
+                  (*custom_map_value).operator->())));
     } else if (native_type_id == NativeTypeId::For<MutableCompatMapValue>()) {
-      return LegacyMapValue(reinterpret_cast<uintptr_t>(
+      return LegacyMapValue(
           static_cast<const google::api::expr::runtime::CelMap*>(
               cel::internal::down_cast<const MutableCompatMapValue*>(
-                  (*custom_map_value).operator->()))));
+                  (*custom_map_value).operator->())));
     }
   }
   return absl::nullopt;

common/values/legacy_map_value.cc

@@ -19,7 +19,6 @@
 #define THIRD_PARTY_CEL_CPP_COMMON_VALUES_LEGACY_MAP_VALUE_H_
 
 #include <cstddef>
-#include <cstdint>
 #include <ostream>
 #include <string>
 
@@ -36,6 +35,10 @@
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/message.h"
 
+namespace google::api::expr::runtime {
+class CelMap;
+}
+
 namespace cel {
 
 class TypeManager;
@@ -50,8 +53,9 @@ class LegacyMapValue final
  public:
   static constexpr ValueKind kKind = ValueKind::kMap;
 
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  explicit LegacyMapValue(uintptr_t impl) : impl_(impl) {}
+  explicit LegacyMapValue(
+      absl::NullabilityUnknown<const google::api::expr::runtime::CelMap*> impl)
+      : impl_(impl) {}
 
   // By default, this creates an empty map whose type is `map(dyn, dyn)`.
   // Unless you can help it, you should use a more specific typed map value.
@@ -148,24 +152,22 @@ class LegacyMapValue final
 
   absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> NewIterator() const;
 
-  void swap(LegacyMapValue& other) noexcept {
-    using std::swap;
-    swap(impl_, other.impl_);
+  absl::Nonnull<const google::api::expr::runtime::CelMap*> cel_map() const {
+    return impl_;
   }
 
-  uintptr_t NativeValue() const { return impl_; }
+  friend void swap(LegacyMapValue& lhs, LegacyMapValue& rhs) noexcept {
+    using std::swap;
+    swap(lhs.impl_, rhs.impl_);
+  }
 
  private:
   friend class common_internal::ValueMixin<LegacyMapValue>;
   friend class common_internal::MapValueMixin<LegacyMapValue>;
 
-  uintptr_t impl_;
+  absl::NullabilityUnknown<const google::api::expr::runtime::CelMap*> impl_;
 };
 
-inline void swap(LegacyMapValue& lhs, LegacyMapValue& rhs) noexcept {
-  lhs.swap(rhs);
-}
-
 inline std::ostream& operator<<(std::ostream& out, const LegacyMapValue& type) {
   return out << type.DebugString();
 }

common/values/legacy_map_value.h

@@ -15,24 +15,14 @@
 #include "absl/log/absl_check.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
-#include "base/internal/message_wrapper.h"
 #include "common/type.h"
 #include "common/value.h"
 #include "google/protobuf/message.h"
-#include "google/protobuf/message_lite.h"
 
 namespace cel::common_internal {
 
 StructType LegacyStructValue::GetRuntimeType() const {
-  if ((message_ptr_ & ::cel::base_internal::kMessageWrapperTagMask) ==
-      ::cel::base_internal::kMessageWrapperTagMessageValue) {
-    return MessageType(
-        google::protobuf::DownCastMessage<google::protobuf::Message>(
-            reinterpret_cast<const google::protobuf::MessageLite*>(
-                message_ptr_ & ::cel::base_internal::kMessageWrapperPtrMask))
-            ->GetDescriptor());
-  }
-  return common_internal::MakeBasicStructType(GetTypeName());
+  return MessageType(message_ptr_->GetDescriptor());
 }
 
 bool IsLegacyStructValue(const Value& value) {

common/values/legacy_struct_value.cc

@@ -40,6 +40,10 @@
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/message.h"
 
+namespace google::api::expr::runtime {
+class LegacyTypeInfoApis;
+}
+
 namespace cel {
 
 class Value;
@@ -57,8 +61,12 @@ class LegacyStructValue final
  public:
   static constexpr ValueKind kKind = ValueKind::kStruct;
 
-  LegacyStructValue(uintptr_t message_ptr, uintptr_t type_info)
-      : message_ptr_(message_ptr), type_info_(type_info) {}
+  LegacyStructValue(
+      absl::NullabilityUnknown<const google::protobuf::Message*> message_ptr,
+      absl::NullabilityUnknown<
+          const google::api::expr::runtime::LegacyTypeInfoApis*>
+          legacy_type_info)
+      : message_ptr_(message_ptr), legacy_type_info_(legacy_type_info) {}
 
   LegacyStructValue(const LegacyStructValue&) = default;
   LegacyStructValue& operator=(const LegacyStructValue&) = default;
@@ -98,12 +106,6 @@ class LegacyStructValue final
 
   bool IsZeroValue() const;
 
-  void swap(LegacyStructValue& other) noexcept {
-    using std::swap;
-    swap(message_ptr_, other.message_ptr_);
-    swap(type_info_, other.type_info_);
-  }
-
   absl::Status GetFieldByName(
       absl::string_view name, ProtoWrapperTypeOptions unboxing_options,
       absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
@@ -138,22 +140,32 @@ class LegacyStructValue final
       absl::Nonnull<int*> count) const;
   using StructValueMixin::Qualify;
 
-  uintptr_t message_ptr() const { return message_ptr_; }
+  absl::NullabilityUnknown<const google::protobuf::Message*> message_ptr() const {
+    return message_ptr_;
+  }
+
+  absl::NullabilityUnknown<
+      const google::api::expr::runtime::LegacyTypeInfoApis*>
+  legacy_type_info() const {
+    return legacy_type_info_;
+  }
 
-  uintptr_t legacy_type_info() const { return type_info_; }
+  friend void swap(LegacyStructValue& lhs, LegacyStructValue& rhs) noexcept {
+    using std::swap;
+    swap(lhs.message_ptr_, rhs.message_ptr_);
+    swap(lhs.legacy_type_info_, rhs.legacy_type_info_);
+  }
 
  private:
   friend class common_internal::ValueMixin<LegacyStructValue>;
   friend class common_internal::StructValueMixin<LegacyStructValue>;
 
-  uintptr_t message_ptr_;
-  uintptr_t type_info_;
+  absl::NullabilityUnknown<const google::protobuf::Message*> message_ptr_;
+  absl::NullabilityUnknown<
+      const google::api::expr::runtime::LegacyTypeInfoApis*>
+      legacy_type_info_;
 };
 
-inline void swap(LegacyStructValue& lhs, LegacyStructValue& rhs) noexcept {
-  lhs.swap(rhs);
-}
-
 inline std::ostream& operator<<(std::ostream& out,
                                 const LegacyStructValue& value) {
   return out << value.DebugString();

common/values/legacy_struct_value.h

@@ -30,8 +30,6 @@
 #include "absl/strings/cord.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "base/internal/message_wrapper.h"
 #include "common/allocator.h"
 #include "common/any.h"
 #include "common/memory.h"
@@ -297,8 +295,7 @@ absl::Status ProtoMessageFromValueImpl(
   // Deal with legacy values.
   if (auto legacy_value = common_internal::AsLegacyStructValue(value);
       legacy_value) {
-    const auto* from_message = reinterpret_cast<const google::protobuf::Message*>(
-        legacy_value->message_ptr() & base_internal::kMessageWrapperPtrMask);
+    const auto* from_message = legacy_value->message_ptr();
     return ProtoMessageCopy(message, to_desc, from_message);
   }