google-protobuf 3.25.8 → 4.32.1

data/ext/google/protobuf_c/message.h

@@ -36,7 +36,7 @@ const upb_Message* Message_GetUpbMessage(VALUE value, const upb_MessageDef* m,
 
 // Gets or constructs a Ruby wrapper object for the given message. The wrapper
 // object will reference |arena| and ensure that it outlives this object.
-VALUE Message_GetRubyWrapper(upb_Message* msg, const upb_MessageDef* m,
+VALUE Message_GetRubyWrapper(const upb_Message* msg, const upb_MessageDef* m,
                              VALUE arena);
 
 // Gets the given field from this message.
@@ -54,10 +54,6 @@ uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
 upb_Message* Message_deep_copy(const upb_Message* msg, const upb_MessageDef* m,
                                upb_Arena* arena);
 
-// Returns true if these two messages are equal.
-bool Message_Equal(const upb_Message* m1, const upb_Message* m2,
-                   const upb_MessageDef* m);
-
 // Checks that this Ruby object is a message, and raises an exception if not.
 void Message_CheckClass(VALUE klass);
 
@@ -78,7 +74,7 @@ VALUE Message_decode_bytes(int size, const char* bytes, int options,
                            VALUE klass, bool freeze);
 
 // Recursively freeze message
-VALUE Message_internal_deep_freeze(VALUE _self);
+VALUE Message_freeze(VALUE _self);
 
 // Call at startup to register all types in this module.
 void Message_register(VALUE protobuf);

data/ext/google/protobuf_c/protobuf.c

@@ -7,8 +7,6 @@
 
 #include "protobuf.h"
 
-#include <ruby/version.h>
-
 #include "defs.h"
 #include "map.h"
 #include "message.h"
@@ -164,16 +162,28 @@ static void Arena_free(void *data) {
   xfree(arena);
 }
 
+static size_t Arena_memsize(const void *data) {
+  const Arena *arena = data;
+  size_t fused_count;
+  size_t memsize = upb_Arena_SpaceAllocated(arena->arena, &fused_count);
+  if (fused_count > 1) {
+    // If other arena were fused we attribute an equal
+    // share of memory usage to each one.
+    memsize /= fused_count;
+  }
+  return memsize + sizeof(Arena);
+}
+
 static VALUE cArena;
 
 const rb_data_type_t Arena_type = {
     "Google::Protobuf::Internal::Arena",
-    {Arena_mark, Arena_free, NULL},
+    {Arena_mark, Arena_free, Arena_memsize},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
-                                size_t size) {
+                                size_t size, size_t *actual_size) {
   if (size == 0) {
     xfree(ptr);
     return NULL;
@@ -209,15 +219,6 @@ void Arena_fuse(VALUE _arena, upb_Arena *other) {
 
 VALUE Arena_new() { return Arena_alloc(cArena); }
 
-void Arena_Pin(VALUE _arena, VALUE obj) {
-  Arena *arena;
-  TypedData_Get_Struct(_arena, Arena, &Arena_type, arena);
-  if (arena->pinned_objs == Qnil) {
-    RB_OBJ_WRITE(_arena, &arena->pinned_objs, rb_ary_new());
-  }
-  rb_ary_push(arena->pinned_objs, obj);
-}
-
 void Arena_register(VALUE module) {
   VALUE internal = rb_define_module_under(module, "Internal");
   VALUE klass = rb_define_class_under(internal, "Arena", rb_cObject);
@@ -241,16 +242,17 @@ static void ObjectCache_Init(VALUE protobuf) {
   item_try_add = rb_intern("try_add");
 
   rb_gc_register_address(&weak_obj_cache);
+  VALUE internal = rb_const_get(protobuf, rb_intern("Internal"));
 #if SIZEOF_LONG >= SIZEOF_VALUE
-  VALUE cache_class = rb_const_get(protobuf, rb_intern("ObjectCache"));
+  VALUE cache_class = rb_const_get(internal, rb_intern("ObjectCache"));
 #else
-  VALUE cache_class = rb_const_get(protobuf, rb_intern("LegacyObjectCache"));
+  VALUE cache_class = rb_const_get(internal, rb_intern("LegacyObjectCache"));
 #endif
 
   weak_obj_cache = rb_class_new_instance(0, NULL, cache_class);
-  rb_const_set(protobuf, rb_intern("OBJECT_CACHE"), weak_obj_cache);
-  rb_const_set(protobuf, rb_intern("SIZEOF_LONG"), INT2NUM(SIZEOF_LONG));
-  rb_const_set(protobuf, rb_intern("SIZEOF_VALUE"), INT2NUM(SIZEOF_VALUE));
+  rb_const_set(internal, rb_intern("OBJECT_CACHE"), weak_obj_cache);
+  rb_const_set(internal, rb_intern("SIZEOF_LONG"), INT2NUM(SIZEOF_LONG));
+  rb_const_set(internal, rb_intern("SIZEOF_VALUE"), INT2NUM(SIZEOF_VALUE));
 }
 
 static VALUE ObjectCache_GetKey(const void *key) {
@@ -284,7 +286,8 @@ VALUE ObjectCache_Get(const void *key) {
 static VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb) {
   const upb_MessageDef *m;
   upb_Message *msg = Message_GetMutable(msg_rb, &m);
-  if (!upb_Message_DiscardUnknown(msg, m, 128)) {
+  const upb_DefPool* ext_pool = upb_FileDef_Pool(upb_MessageDef_File(m));
+  if (!upb_Message_DiscardUnknown(msg, m, ext_pool, 128)) {
     rb_raise(rb_eRuntimeError, "Messages nested too deeply.");
   }
 
@@ -341,3 +344,14 @@ __attribute__((visibility("default"))) void Init_protobuf_c() {
   rb_define_singleton_method(protobuf, "deep_copy", Google_Protobuf_deep_copy,
                              1);
 }
+
+// -----------------------------------------------------------------------------
+// Utilities
+// -----------------------------------------------------------------------------
+
+// Raises a Ruby error if val is frozen in Ruby or UPB.
+void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen) {
+  if (RB_UNLIKELY(rb_obj_frozen_p(val)||upb_frozen)) {
+    rb_error_frozen_object(val);
+  }
+}

data/ext/google/protobuf_c/protobuf.h

@@ -16,12 +16,6 @@
 #undef NDEBUG
 #endif
 
-#include <ruby/version.h>
-
-#if RUBY_API_VERSION_CODE < 20700
-#error Protobuf requires Ruby >= 2.7
-#endif
-
 #include <assert.h>  // Must be included after the NDEBUG logic above.
 #include <ruby/encoding.h>
 #include <ruby/vm.h>
@@ -50,13 +44,6 @@ upb_Arena* Arena_get(VALUE arena);
 // possible.
 void Arena_fuse(VALUE arena, upb_Arena* other);
 
-// Pins this Ruby object to the lifetime of this arena, so that as long as the
-// arena is alive this object will not be collected.
-//
-// We use this to guarantee that the "frozen" bit on the object will be
-// remembered, even if the user drops their reference to this precise object.
-void Arena_Pin(VALUE arena, VALUE obj);
-
 // -----------------------------------------------------------------------------
 // ObjectCache
 // -----------------------------------------------------------------------------
@@ -105,8 +92,9 @@ extern VALUE cTypeError;
   rb_bug("Assertion failed at %s:%d, expr: %s", __FILE__, __LINE__, #expr)
 #endif
 
-#define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y))
+// Raises a Ruby error if val is frozen in Ruby or upb_frozen is true.
+void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen);
 
-#define UPB_UNUSED(var) (void)var
+#define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y))
 
 #endif  // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__

data/ext/google/protobuf_c/repeated_field.c

@@ -44,8 +44,9 @@ static RepeatedField* ruby_to_RepeatedField(VALUE _self) {
 }
 
 static upb_Array* RepeatedField_GetMutable(VALUE _self) {
-  rb_check_frozen(_self);
-  return (upb_Array*)ruby_to_RepeatedField(_self)->array;
+  const upb_Array* array = ruby_to_RepeatedField(_self)->array;
+  Protobuf_CheckNotFrozen(_self, upb_Array_IsFrozen(array));
+  return (upb_Array*)array;
 }
 
 VALUE RepeatedField_alloc(VALUE klass) {
@@ -56,9 +57,32 @@ VALUE RepeatedField_alloc(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &RepeatedField_type, self);
 }
 
-VALUE RepeatedField_GetRubyWrapper(upb_Array* array, TypeInfo type_info,
+VALUE RepeatedField_EmptyFrozen(const upb_FieldDef* f) {
+  PBRUBY_ASSERT(upb_FieldDef_IsRepeated(f));
+  VALUE val = ObjectCache_Get(f);
+
+  if (val == Qnil) {
+    val = RepeatedField_alloc(cRepeatedField);
+    RepeatedField* self;
+    TypedData_Get_Struct(val, RepeatedField, &RepeatedField_type, self);
+    self->arena = Arena_new();
+    TypeInfo type_info = TypeInfo_get(f);
+    self->array = upb_Array_New(Arena_get(self->arena), type_info.type);
+    self->type_info = type_info;
+    if (self->type_info.type == kUpb_CType_Message) {
+      self->type_class = Descriptor_DefToClass(type_info.def.msgdef);
+    }
+    val = ObjectCache_TryAdd(f, RepeatedField_freeze(val));
+  }
+  PBRUBY_ASSERT(RB_OBJ_FROZEN(val));
+  PBRUBY_ASSERT(upb_Array_IsFrozen(ruby_to_RepeatedField(val)->array));
+  return val;
+}
+
+VALUE RepeatedField_GetRubyWrapper(const upb_Array* array, TypeInfo type_info,
                                    VALUE arena) {
   PBRUBY_ASSERT(array);
+  PBRUBY_ASSERT(arena != Qnil);
   VALUE val = ObjectCache_Get(array);
 
   if (val == Qnil) {
@@ -78,7 +102,6 @@ VALUE RepeatedField_GetRubyWrapper(upb_Array* array, TypeInfo type_info,
   PBRUBY_ASSERT(ruby_to_RepeatedField(val)->type_info.def.msgdef ==
                 type_info.def.msgdef);
   PBRUBY_ASSERT(ruby_to_RepeatedField(val)->array == array);
-
   return val;
 }
 
@@ -169,13 +192,20 @@ static VALUE RepeatedField_subarray(RepeatedField* self, long beg, long len) {
   return ary;
 }
 
+/**
+ * ruby-doc: RepeatedField
+ *
+ */
+
 /*
- * call-seq:
- *     RepeatedField.each(&block)
+ * ruby-doc: RepeatedField#each
  *
  * Invokes the block once for each element of the repeated field. RepeatedField
  * also includes Enumerable; combined with this method, the repeated field thus
  * acts like an ordinary Ruby sequence.
+ *
+ * @yield [Object]
+ * @return [self]
  */
 static VALUE RepeatedField_each(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -191,10 +221,12 @@ static VALUE RepeatedField_each(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.[](index) => value
+ * ruby-doc: RepeatedField#[]
  *
  * Accesses the element at the given index. Returns nil on out-of-bounds
+ *
+ * @param index [Integer]
+ * @return [Object,nil]
  */
 static VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -239,11 +271,14 @@ static VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.[]=(index, value)
+ * ruby-doc: RepeatedField#[]=
  *
  * Sets the element at the given index. On out-of-bounds assignments, extends
  * the array and fills the hole (if any) with default values.
+ *
+ * @param index [Integer]
+ * @param value [Object
+ * @return [nil]
  */
 static VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -273,10 +308,12 @@ static VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.push(value, ...)
+ * ruby-doc: RepeatedField#push
  *
  * Adds a new element to the repeated field.
+ *
+ * @param value [Object]
+ * @return [self]
  */
 static VALUE RepeatedField_push_vararg(int argc, VALUE* argv, VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -294,10 +331,12 @@ static VALUE RepeatedField_push_vararg(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.<<(value)
+ * ruby-doc: RepeatedField#<<
  *
  * Adds a new element to the repeated field.
+ *
+ * @param value [Object]
+ * @return [self]
  */
 static VALUE RepeatedField_push(VALUE _self, VALUE val) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -332,10 +371,12 @@ static VALUE RepeatedField_pop_one(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.replace(list)
+ * ruby-doc: RepeatedField#replace
  *
  * Replaces the contents of the repeated field with the given list of elements.
+ *
+ * @param list [Array]
+ * @return [Array]
  */
 static VALUE RepeatedField_replace(VALUE _self, VALUE list) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -353,10 +394,11 @@ static VALUE RepeatedField_replace(VALUE _self, VALUE list) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.clear
+ * ruby-doc: RepeatedField#clear
  *
  * Clears (removes all elements from) this repeated field.
+ *
+ * @return [self]
  */
 static VALUE RepeatedField_clear(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -366,10 +408,11 @@ static VALUE RepeatedField_clear(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.length
+ * ruby-doc: RepeatedField#length
  *
  * Returns the length of this repeated field.
+ *
+ * @return [Integer]
  */
 static VALUE RepeatedField_length(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -377,11 +420,12 @@ static VALUE RepeatedField_length(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.dup => repeated_field
+ * ruby-doc: RepeatedField#dup
  *
  * Duplicates this repeated field with a shallow copy. References to all
  * non-primitive element objects (e.g., submessages) are shared.
+ *
+ * @return [RepeatedField]
  */
 static VALUE RepeatedField_dup(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -403,11 +447,12 @@ static VALUE RepeatedField_dup(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.to_ary => array
+ * ruby-doc: RepeatedField#to_ary
  *
  * Used when converted implicitly into array, e.g. compared to an Array.
  * Also called as a fallback of Object#to_a
+ *
+ * @return [Array]
  */
 VALUE RepeatedField_to_ary(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -425,8 +470,7 @@ VALUE RepeatedField_to_ary(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.==(other) => boolean
+ * ruby-doc: RepeatedField#==
  *
  * Compares this repeated field to another. Repeated fields are equal if their
  * element types are equal, their lengths are equal, and each element is equal.
@@ -436,6 +480,9 @@ VALUE RepeatedField_to_ary(VALUE _self) {
  * Repeated fields with dissimilar element types are never equal, even if value
  * comparison (for example, between integers and floats) would have otherwise
  * indicated that every element has equal value.
+ *
+ * @param other [RepeatedField]
+ * @return [Boolean]
  */
 VALUE RepeatedField_eq(VALUE _self, VALUE _other) {
   RepeatedField* self;
@@ -472,45 +519,59 @@ VALUE RepeatedField_eq(VALUE _self, VALUE _other) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.freeze => self
+ * ruby-doc: RepeatedField#frozen?
+ *
+ * Returns true if the repeated field is frozen in either Ruby or the underlying
+ * representation. Freezes the Ruby repeated field object if it is not already
+ * frozen in Ruby but it is frozen in the underlying representation.
  *
- * Freezes the repeated field. We have to intercept this so we can pin the Ruby
- * object into memory so we don't forget it's frozen.
+ * @return [Boolean]
  */
-static VALUE RepeatedField_freeze(VALUE _self) {
+VALUE RepeatedField_frozen(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
-  if (!RB_OBJ_FROZEN(_self)) {
-    Arena_Pin(self->arena, _self);
-    RB_OBJ_FREEZE(_self);
+  if (!upb_Array_IsFrozen(self->array)) {
+    PBRUBY_ASSERT(!RB_OBJ_FROZEN(_self));
+    return Qfalse;
   }
-  return _self;
+
+  // Lazily freeze the Ruby wrapper.
+  if (!RB_OBJ_FROZEN(_self)) RB_OBJ_FREEZE(_self);
+  return Qtrue;
 }
 
 /*
- * Deep freezes the repeated field and values recursively.
- * Internal use only.
+ * ruby-doc: RepeatedField#freeze
+ *
+ * Freezes the repeated field object. We have to intercept this so we can freeze
+ * the underlying representation, not just the Ruby wrapper.
+ *
+ * @return [self]
  */
-VALUE RepeatedField_internal_deep_freeze(VALUE _self) {
+VALUE RepeatedField_freeze(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
-  RepeatedField_freeze(_self);
-  if (self->type_info.type == kUpb_CType_Message) {
-    int size = upb_Array_Size(self->array);
-    int i;
-    for (i = 0; i < size; i++) {
-      upb_MessageValue msgval = upb_Array_Get(self->array, i);
-      VALUE val = Convert_UpbToRuby(msgval, self->type_info, self->arena);
-      Message_internal_deep_freeze(val);
+  if (RB_OBJ_FROZEN(_self)) {
+    PBRUBY_ASSERT(upb_Array_IsFrozen(self->array));
+    return _self;
+  }
+
+  if (!upb_Array_IsFrozen(self->array)) {
+    if (self->type_info.type == kUpb_CType_Message) {
+      upb_Array_Freeze(RepeatedField_GetMutable(_self),
+                       upb_MessageDef_MiniTable(self->type_info.def.msgdef));
+    } else {
+      upb_Array_Freeze(RepeatedField_GetMutable(_self), NULL);
     }
   }
+  RB_OBJ_FREEZE(_self);
   return _self;
 }
 
 /*
- * call-seq:
- *     RepeatedField.hash => hash_value
+ * ruby-doc: RepeatedField#hash
  *
  * Returns a hash value computed from this repeated field's elements.
+ *
+ * @return [Integer]
  */
 VALUE RepeatedField_hash(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -526,12 +587,14 @@ VALUE RepeatedField_hash(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.+(other) => repeated field
+ * ruby-doc: RepeatedField#+
  *
  * Returns a new repeated field that contains the concatenated list of this
  * repeated field's elements and other's elements. The other (second) list may
  * be either another repeated field or a Ruby array.
+ *
+ * @param other [Array,RepeatedField]
+ * @return [RepeatedField]
  */
 VALUE RepeatedField_plus(VALUE _self, VALUE list) {
   VALUE dupped_ = RepeatedField_dup(_self);
@@ -571,10 +634,12 @@ VALUE RepeatedField_plus(VALUE _self, VALUE list) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.concat(other) => self
+ * ruby-doc: RepeatedField#concat
  *
  * concats the passed in array to self.  Returns a Ruby array.
+ *
+ * @param other [RepeatedField]
+ * @return [Array]
  */
 VALUE RepeatedField_concat(VALUE _self, VALUE list) {
   int i;
@@ -587,15 +652,21 @@ VALUE RepeatedField_concat(VALUE _self, VALUE list) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.new(type, type_class = nil, initial_elems = [])
+ * ruby-doc: RepeatedField#initialize
  *
  * Creates a new repeated field. The provided type must be a Ruby symbol, and
- * can take on the same values as those accepted by FieldDescriptor#type=. If
+ * can take on the same values as those accepted by {FieldDescriptor#type=}. If
  * the type is :message or :enum, type_class must be non-nil, and must be the
- * Ruby class or module returned by Descriptor#msgclass or
- * EnumDescriptor#enummodule, respectively. An initial list of elements may also
- * be provided.
+ * Ruby class or module returned by {Descriptor#msgclass} or
+ * {EnumDescriptor#enummodule}, respectively. An initial list of elements may
+ * also be provided.
+ *
+ * @param type [Symbol]
+ * @param type_class [Class<AbstractMessage>, Module]
+ * @paramdefault type_class nil
+ * @param initial_elems [Array]
+ * @paramdefault initial_elems []
+ * @return [RepeatedField]
  */
 VALUE RepeatedField_init(int argc, VALUE* argv, VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -649,6 +720,7 @@ void RepeatedField_register(VALUE module) {
   rb_define_method(klass, "==", RepeatedField_eq, 1);
   rb_define_method(klass, "to_ary", RepeatedField_to_ary, 0);
   rb_define_method(klass, "freeze", RepeatedField_freeze, 0);
+  rb_define_method(klass, "frozen?", RepeatedField_frozen, 0);
   rb_define_method(klass, "hash", RepeatedField_hash, 0);
   rb_define_method(klass, "+", RepeatedField_plus, 1);
   rb_define_method(klass, "concat", RepeatedField_concat, 1);

data/ext/google/protobuf_c/repeated_field.h

@@ -11,9 +11,13 @@
 #include "protobuf.h"
 #include "ruby-upb.h"
 
+// Returns a frozen sentinel Ruby wrapper object for an empty upb_Array of the
+// type specified by the field. Creates one if it doesn't exist.
+VALUE RepeatedField_EmptyFrozen(const upb_FieldDef* f);
+
 // Returns a Ruby wrapper object for the given upb_Array, which will be created
 // if one does not exist already.
-VALUE RepeatedField_GetRubyWrapper(upb_Array* msg, TypeInfo type_info,
+VALUE RepeatedField_GetRubyWrapper(const upb_Array* msg, TypeInfo type_info,
                                    VALUE arena);
 
 // Gets the underlying upb_Array for this Ruby RepeatedField object, which must
@@ -36,6 +40,6 @@ extern VALUE cRepeatedField;
 void RepeatedField_register(VALUE module);
 
 // Recursively freeze RepeatedField.
-VALUE RepeatedField_internal_deep_freeze(VALUE _self);
+VALUE RepeatedField_freeze(VALUE _self);
 
 #endif  // RUBY_PROTOBUF_REPEATED_FIELD_H_