Add MicroString support for DynamicMessage types.

This support is currently experimental and enabled via opt-in flag.

PiperOrigin-RevId: 743666524

Author: protobuf-github-bot

src/google/protobuf/BUILD.bazel

@@ -712,6 +712,7 @@ cc_library(
     ],
     deps = [
         ":internal_visibility",
+        ":micro_string",
         ":port",
         ":protobuf_lite",
         "//src/google/protobuf/io",

src/google/protobuf/dynamic_message.cc

@@ -64,6 +64,7 @@
 #include "google/protobuf/map.h"
 #include "google/protobuf/map_field.h"
 #include "google/protobuf/message_lite.h"
+#include "google/protobuf/micro_string.h"
 #include "google/protobuf/port.h"
 #include "google/protobuf/repeated_field.h"
 #include "google/protobuf/unknown_field_set.h"
@@ -79,6 +80,7 @@ using internal::ExtensionSet;
 
 
 using internal::ArenaStringPtr;
+using internal::MicroString;
 
 // ===================================================================
 // Some helper tables and functions...
@@ -242,6 +244,10 @@ int FieldSpaceUsed(const FieldDescriptor* field) {
           case FieldDescriptor::CppStringType::kCord:
             return sizeof(absl::Cord);
           case FieldDescriptor::CppStringType::kView:
+            if (internal::EnableExperimentalMicroString()) {
+              return sizeof(MicroString);
+            }
+            [[fallthrough]];
           case FieldDescriptor::CppStringType::kString:
             return sizeof(ArenaStringPtr);
         }
@@ -253,6 +259,17 @@ int FieldSpaceUsed(const FieldDescriptor* field) {
   return 0;
 }
 
+uint32_t FieldFlags(const FieldDescriptor* field) {
+  if (internal::EnableExperimentalMicroString() &&   //
+      !field->is_repeated() &&                       //
+      !field->is_extension() &&                      //
+      field->cpp_type() == field->CPPTYPE_STRING &&  //
+      field->cpp_string_type() == FieldDescriptor::CppStringType::kView) {
+    return internal::kMicroStringMask;
+  }
+  return 0;
+}
+
 inline int DivideRoundingUp(int i, int j) { return (i + (j - 1)) / j; }
 
 static const int kSafeAlignment = sizeof(uint64_t);
@@ -326,7 +343,11 @@ class DynamicMessage final : public Message {
   static void* NewImpl(const void* prototype, void* mem, Arena* arena);
   static void DestroyImpl(MessageLite& ptr);
 
-  void* MutableRaw(int i);
+  // If `T` is not `void`, it will mask bits off the offset via alignment.
+  // Used to remove feature masks that are part of the reflection
+  // implementation.
+  template <typename T = void>
+  T* MutableRaw(int i);
   void* MutableExtensionsRaw();
   void* MutableWeakFieldMapRaw();
   void* MutableOneofCaseRaw(int i);
@@ -416,8 +437,13 @@ DynamicMessage::DynamicMessage(DynamicMessageFactory::TypeInfo* type_info,
   SharedCtor(lock_factory);
 }
 
-inline void* DynamicMessage::MutableRaw(int i) {
-  return OffsetToPointer(type_info_->offsets[i]);
+template <typename T>
+inline T* DynamicMessage::MutableRaw(int i) {
+  uint32_t mask = ~uint32_t{};
+  if constexpr (!std::is_void_v<T>) {
+    mask = ~(uint32_t{alignof(T)} - 1);
+  }
+  return reinterpret_cast<T*>(OffsetToPointer(type_info_->offsets[i] & mask));
 }
 inline void* DynamicMessage::MutableExtensionsRaw() {
   return OffsetToPointer(type_info_->extensions_offset);
@@ -513,6 +539,16 @@ void DynamicMessage::SharedCtor(bool lock_factory) {
             }
             break;
           case FieldDescriptor::CppStringType::kView:
+            if (internal::EnableExperimentalMicroString() &&
+                !field->is_repeated()) {
+              auto* str = ::new (MutableRaw<MicroString>(i)) MicroString();
+              if (field->has_default_value()) {
+                // TODO: Use an unowned block instead.
+                str->Set(field->default_value_string(), arena);
+              }
+              break;
+            }
+            [[fallthrough]];
           case FieldDescriptor::CppStringType::kString:
             if (!field->is_repeated()) {
               ArenaStringPtr* asp = new (field_ptr) ArenaStringPtr();
@@ -600,6 +636,11 @@ DynamicMessage::~DynamicMessage() {
               delete *reinterpret_cast<absl::Cord**>(field_ptr);
               break;
             case FieldDescriptor::CppStringType::kView:
+              if (internal::EnableExperimentalMicroString()) {
+                reinterpret_cast<MicroString*>(field_ptr)->Destroy();
+                break;
+              }
+              [[fallthrough]];
             case FieldDescriptor::CppStringType::kString: {
               reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy();
               break;
@@ -661,6 +702,11 @@ DynamicMessage::~DynamicMessage() {
           reinterpret_cast<absl::Cord*>(field_ptr)->~Cord();
           break;
         case FieldDescriptor::CppStringType::kView:
+          if (internal::EnableExperimentalMicroString()) {
+            MutableRaw<MicroString>(i)->Destroy();
+            break;
+          }
+          [[fallthrough]];
         case FieldDescriptor::CppStringType::kString: {
           reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy();
           break;
@@ -868,7 +914,7 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
     if (!InRealOneof(type->field(i))) {
       int field_size = FieldSpaceUsed(type->field(i));
       size = AlignTo(size, std::min(kSafeAlignment, field_size));
-      offsets[i] = size;
+      offsets[i] = size | FieldFlags(type->field(i));
       size += field_size;
     }
   }
@@ -893,11 +939,11 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
     for (int j = 0; j < type->real_oneof_decl(i)->field_count(); j++) {
       const FieldDescriptor* field = type->real_oneof_decl(i)->field(j);
       // oneof fields are not accessed through offsets, but we still have the
-      // entry from a legacy implementation. This should be removed at some
-      // point.
+      // entry for each.
       // Mark the field to prevent unintentional access through reflection.
       // Don't use the top bit because that is for unused fields.
-      offsets[field->index()] = internal::kInvalidFieldOffsetTag;
+      offsets[field->index()] =
+          internal::kInvalidFieldOffsetTag | FieldFlags(field);
     }
   }