google-protobuf 4.27.2 → 4.35.1

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,36 +519,59 @@ VALUE RepeatedField_eq(VALUE _self, VALUE _other) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.freeze => self
+ * ruby-doc: RepeatedField#frozen?
  *
- * 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.
+ * 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.
+ *
+ * @return [Boolean]
  */
-VALUE RepeatedField_freeze(VALUE _self) {
+VALUE RepeatedField_frozen(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
+  if (!upb_Array_IsFrozen(self->array)) {
+    PBRUBY_ASSERT(!RB_OBJ_FROZEN(_self));
+    return Qfalse;
+  }
 
-  if (RB_OBJ_FROZEN(_self)) return _self;
-  Arena_Pin(self->arena, _self);
-  RB_OBJ_FREEZE(_self);
+  // Lazily freeze the Ruby wrapper.
+  if (!RB_OBJ_FROZEN(_self)) RB_OBJ_FREEZE(_self);
+  return Qtrue;
+}
 
-  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_freeze(val);
+/*
+ * 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_freeze(VALUE _self) {
+  RepeatedField* self = ruby_to_RepeatedField(_self);
+  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);
@@ -517,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);
@@ -562,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;
@@ -578,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);
@@ -640,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