Update bit math constants for tagged messages for interop.

Updated names should help readability since the tagging scheme is overloaded for both lite proto support and for handle migration.

PiperOrigin-RevId: 534145645

Author: jnthntatum

base/internal/message_wrapper.h

@@ -19,8 +19,11 @@
 
 namespace cel::base_internal {
 
-inline constexpr uintptr_t kMessageWrapperTagMask = 1 << 0;
+inline constexpr uintptr_t kMessageWrapperTagMask = 0b1;
 inline constexpr uintptr_t kMessageWrapperPtrMask = ~kMessageWrapperTagMask;
+inline constexpr uintptr_t kMessageWrapperTagSize = 1;
+inline constexpr uintptr_t kMessageWrapperTagTypeInfoValue = 0b0;
+inline constexpr uintptr_t kMessageWrapperTagMessageValue = 0b1;
 
 }  // namespace cel::base_internal
 

base/values/struct_value.cc

@@ -179,11 +179,13 @@ class LegacyStructValueFieldIterator final : public StructValue::FieldIterator {
 };
 
 Handle<StructType> LegacyStructValue::type() const {
-  if ((msg_ & kMessageWrapperTagMask) == kMessageWrapperTagMask) {
+  uintptr_t tag = msg_ & kMessageWrapperTagMask;
+  if (tag == kMessageWrapperTagMessageValue) {
     // google::protobuf::Message
     return HandleFactory<StructType>::Make<LegacyStructType>(msg_);
   }
   // LegacyTypeInfoApis
+  ABSL_ASSERT(tag == kMessageWrapperTagTypeInfoValue);
   return HandleFactory<StructType>::Make<LegacyStructType>(type_info_);
 }
 

eval/internal/BUILD

@@ -22,8 +22,7 @@ cc_library(
     hdrs = ["interop.h"],
     deps = [
         ":errors",
-        "//base:type",
-        "//base:value",
+        "//base:data",
         "//base/internal:message_wrapper",
         "//eval/public:cel_options",
         "//eval/public:cel_value",
@@ -51,14 +50,15 @@ cc_test(
     deps = [
         ":errors",
         ":interop",
+        "//base:data",
         "//base:memory",
-        "//base:type",
-        "//base:value",
         "//eval/public:cel_value",
+        "//eval/public:message_wrapper",
         "//eval/public:unknown_set",
         "//eval/public/containers:container_backed_list_impl",
         "//eval/public/containers:container_backed_map_impl",
         "//eval/public/structs:cel_proto_wrapper",
+        "//eval/public/structs:trivial_legacy_type_info",
         "//extensions/protobuf:memory_manager",
         "//extensions/protobuf:type",
         "//extensions/protobuf:value",

eval/internal/interop.cc

@@ -14,6 +14,7 @@
 
 #include "eval/internal/interop.h"
 
+#include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
@@ -43,6 +44,7 @@
 #include "eval/public/unknown_set.h"
 #include "extensions/protobuf/memory_manager.h"
 #include "internal/status_macros.h"
+#include "google/protobuf/message.h"
 
 namespace cel::interop_internal {
 
@@ -667,12 +669,17 @@ using ::google::api::expr::runtime::MessageWrapper;
 }  // namespace
 
 absl::string_view MessageTypeName(uintptr_t msg) {
-  if ((msg & kMessageWrapperTagMask) != kMessageWrapperTagMask) {
+  uintptr_t tag = (msg & kMessageWrapperTagMask);
+  uintptr_t ptr = (msg & kMessageWrapperPtrMask);
+
+  if (tag == kMessageWrapperTagTypeInfoValue) {
     // For google::protobuf::MessageLite, this is actually LegacyTypeInfoApis.
-    return reinterpret_cast<const LegacyTypeInfoApis*>(msg)->GetTypename(
+    return reinterpret_cast<const LegacyTypeInfoApis*>(ptr)->GetTypename(
         MessageWrapper());
   }
-  return reinterpret_cast<const google::protobuf::Message*>(msg & kMessageWrapperPtrMask)
+  ABSL_ASSERT(tag == kMessageWrapperTagMessageValue);
+
+  return reinterpret_cast<const google::protobuf::Message*>(ptr)
       ->GetDescriptor()
       ->full_name();
 }

eval/internal/interop_test.cc

@@ -21,6 +21,7 @@
 #include <vector>
 
 #include "google/protobuf/api.pb.h"
+#include "google/protobuf/empty.pb.h"
 #include "google/protobuf/arena.h"
 #include "absl/status/status.h"
 #include "absl/strings/escaping.h"
@@ -36,7 +37,9 @@
 #include "eval/public/cel_value.h"
 #include "eval/public/containers/container_backed_list_impl.h"
 #include "eval/public/containers/container_backed_map_impl.h"
+#include "eval/public/message_wrapper.h"
 #include "eval/public/structs/cel_proto_wrapper.h"
+#include "eval/public/structs/trivial_legacy_type_info.h"
 #include "eval/public/unknown_set.h"
 #include "extensions/protobuf/memory_manager.h"
 #include "extensions/protobuf/type_provider.h"
@@ -49,6 +52,7 @@ namespace {
 using ::google::api::expr::runtime::CelProtoWrapper;
 using ::google::api::expr::runtime::CelValue;
 using ::google::api::expr::runtime::ContainerBackedListImpl;
+using ::google::api::expr::runtime::MessageWrapper;
 using ::google::api::expr::runtime::UnknownSet;
 using testing::Eq;
 using testing::HasSubstr;
@@ -763,6 +767,38 @@ TEST(ValueInterop, StructFromLegacy) {
             value_wrapper.legacy_type_info());
 }
 
+TEST(ValueInterop, StructFromLegacyMessageLite) {
+  google::protobuf::Arena arena;
+  extensions::ProtoMemoryManager memory_manager(&arena);
+  TypeFactory type_factory(memory_manager);
+  TypeManager type_manager(type_factory, TypeProvider::Builtin());
+  ValueFactory value_factory(type_manager);
+  google::protobuf::Empty opaque;
+  MessageWrapper wrapper(
+      static_cast<const google::protobuf::MessageLite*>(&opaque),
+      google::api::expr::runtime::TrivialTypeInfo::GetInstance());
+  CelValue legacy_value = CelValue::CreateMessageWrapper(wrapper);
+  ASSERT_OK_AND_ASSIGN(auto value, FromLegacyValue(&arena, legacy_value));
+  EXPECT_EQ(value->kind(), Kind::kStruct);
+  EXPECT_EQ(value->type()->kind(), Kind::kStruct);
+  EXPECT_EQ(value->type()->name(), "opaque type");
+  EXPECT_THAT(
+      value.As<StructValue>()->HasFieldByName(
+          StructValue::HasFieldContext(type_manager), "name"),
+      StatusIs(absl::StatusCode::kNotFound, HasSubstr("no_such_field")));
+  EXPECT_THAT(value.As<StructValue>()->HasFieldByNumber(
+                  StructValue::HasFieldContext(type_manager), 1),
+              StatusIs(absl::StatusCode::kUnimplemented));
+  EXPECT_EQ(value.As<StructValue>()->DebugString(), "opaque type");
+  auto value_wrapper = LegacyStructValueAccess::ToMessageWrapper(
+      *value.As<base_internal::LegacyStructValue>());
+  auto legacy_value_wrapper = legacy_value.MessageWrapperOrDie();
+  EXPECT_EQ(legacy_value_wrapper.HasFullProto(), value_wrapper.HasFullProto());
+  EXPECT_EQ(legacy_value_wrapper.message_ptr(), value_wrapper.message_ptr());
+  EXPECT_EQ(legacy_value_wrapper.legacy_type_info(),
+            value_wrapper.legacy_type_info());
+}
+
 TEST(ValueInterop, LegacyStructRoundtrip) {
   google::protobuf::Arena arena;
   extensions::ProtoMemoryManager memory_manager(&arena);

eval/public/message_wrapper.h

@@ -45,18 +45,22 @@ class MessageWrapper {
    public:
     explicit Builder(google::protobuf::MessageLite* message)
         : message_ptr_(reinterpret_cast<uintptr_t>(message)) {
-      ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >= 1);
+      ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >=
+                  kTagSize);
     }
     explicit Builder(google::protobuf::Message* message)
-        : message_ptr_(reinterpret_cast<uintptr_t>(message) | kTagMask) {
-      ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >= 1);
+        : message_ptr_(reinterpret_cast<uintptr_t>(message) | kMessageTag) {
+      ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >=
+                  kTagSize);
     }
 
     google::protobuf::MessageLite* message_ptr() const {
       return reinterpret_cast<google::protobuf::MessageLite*>(message_ptr_ & kPtrMask);
     }
 
-    bool HasFullProto() const { return (message_ptr_ & kTagMask) == kTagMask; }
+    bool HasFullProto() const {
+      return (message_ptr_ & kTagMask) == kMessageTag;
+    }
 
     MessageWrapper Build(const LegacyTypeInfoApis* type_info) {
       return MessageWrapper(message_ptr_, type_info);
@@ -78,19 +82,21 @@ class MessageWrapper {
                  const LegacyTypeInfoApis* legacy_type_info)
       : message_ptr_(reinterpret_cast<uintptr_t>(message)),
         legacy_type_info_(legacy_type_info) {
-    ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >= 1);
+    ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >=
+                kTagSize);
   }
 
   MessageWrapper(const google::protobuf::Message* message,
                  const LegacyTypeInfoApis* legacy_type_info)
-      : message_ptr_(reinterpret_cast<uintptr_t>(message) | kTagMask),
+      : message_ptr_(reinterpret_cast<uintptr_t>(message) | kMessageTag),
         legacy_type_info_(legacy_type_info) {
-    ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >= 1);
+    ABSL_ASSERT(absl::countr_zero(reinterpret_cast<uintptr_t>(message)) >=
+                kTagSize);
   }
 
   // If true, the message is using the full proto runtime and downcasting to
   // message should be safe.
-  bool HasFullProto() const { return (message_ptr_ & kTagMask) == kTagMask; }
+  bool HasFullProto() const { return (message_ptr_ & kTagMask) == kMessageTag; }
 
   // Returns the underlying message.
   //
@@ -114,10 +120,14 @@ class MessageWrapper {
 
   Builder ToBuilder() { return Builder(message_ptr_); }
 
+  static constexpr uintptr_t kTagSize =
+      ::cel::base_internal::kMessageWrapperTagSize;
   static constexpr uintptr_t kTagMask =
       ::cel::base_internal::kMessageWrapperTagMask;
   static constexpr uintptr_t kPtrMask =
       ::cel::base_internal::kMessageWrapperPtrMask;
+  static constexpr uintptr_t kMessageTag =
+      ::cel::base_internal::kMessageWrapperTagMessageValue;
   uintptr_t message_ptr_;
   const LegacyTypeInfoApis* legacy_type_info_;
 };