google-protobuf 4.27.0 → 4.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9d09852bece37b8bca993ca4c8ccc4d11d151e9a82eca9d11ffd136f71a96c2
-  data.tar.gz: 1a0741956cf395ce9f91cbcf055dff0eb53034c73b1666c42bc22c9cc4b3f73d
+  metadata.gz: 531c1d4e78630f992244bac8fac8176297a60073b58bd92d344083f478f8dcb5
+  data.tar.gz: de1b062231118253de9063e495ce188907760bf536a368a426d0ab1cf59ea5bb
 SHA512:
-  metadata.gz: 3f3ac4559a0ac4b049cf0f816fc3ccaba326974cebbefa5e221bef1167dd0c30f8691eb9bdfa0182f172d1e066ff75b992561297265e62c94daed6725fc39acf
-  data.tar.gz: 41e2d3a3afa99d56ffb5e276a43ced20ddd028bcca60e80c0e7cbc962b239f88bf139df0498d06b86924ebf46a095f6b6bf9bd4baa00397e6fc6dc9ed6f7e5ad
+  metadata.gz: ec022839412e0210fa1cd44b34d96defb2c83a0ca7c1b84bc62f00526f2af64d70abbfda7c405b0a8eaa718ab366a80bbbd7ee3a072144a539282adc7fb24059
+  data.tar.gz: 87463961cb841e762147dcdbd648557cd0a5228e122a717f6429220d485a2dea1fe32f3f1efbcb71504e2b2ad1a191810adcf4327c93bcb047bb6fb244a7748b

data/ext/google/protobuf_c/convert.c

@@ -104,6 +104,41 @@ unknownval:
   rb_raise(rb_eRangeError, "Unknown symbol value for enum field '%s'.", name);
 }
 
+VALUE Convert_CheckStringUtf8(VALUE str) {
+  VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
+
+  if (rb_obj_encoding(str) == utf8) {
+    // Note: Just because a string is marked as having UTF-8 encoding does
+    // not mean that it is *valid* UTF-8.  We have to check separately
+    // whether it is valid.
+    if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
+      // TODO: For now
+      // we only warn for this case.  We will remove the warning and throw an
+      // exception below in the 30.x release
+
+      rb_warn(
+          "String is invalid UTF-8. This will be an error in a future "
+          "version.");
+      // VALUE exc = rb_const_get_at(
+      //     rb_cEncoding, rb_intern("InvalidByteSequenceError"));
+      // rb_raise(exc, "String is invalid UTF-8");
+    }
+  } else {
+    // Note: this will not duplicate underlying string data unless
+    // necessary.
+    //
+    // This will throw an exception if the conversion cannot be performed:
+    // - Encoding::UndefinedConversionError if certain characters cannot be
+    //   converted to UTF-8.
+    // - Encoding::InvalidByteSequenceError if certain characters were invalid
+    //   in the source encoding.
+    str = rb_str_encode(str, utf8, 0, Qnil);
+    PBRUBY_ASSERT(rb_enc_str_coderange(str) != ENC_CODERANGE_BROKEN);
+  }
+
+  return str;
+}
+
 upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
                                    TypeInfo type_info, upb_Arena* arena) {
   upb_MessageValue ret;
@@ -137,8 +172,7 @@ upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
       }
       break;
     }
-    case kUpb_CType_String: {
-      VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
+    case kUpb_CType_String:
       if (rb_obj_class(value) == rb_cSymbol) {
         value = rb_funcall(value, rb_intern("to_s"), 0);
       } else if (!rb_obj_is_kind_of(value, rb_cString)) {
@@ -147,19 +181,9 @@ upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
                  rb_class2name(CLASS_OF(value)));
       }
 
-      if (rb_obj_encoding(value) != utf8) {
-        // Note: this will not duplicate underlying string data unless
-        // necessary.
-        value = rb_str_encode(value, utf8, 0, Qnil);
-
-        if (rb_enc_str_coderange(value) == ENC_CODERANGE_BROKEN) {
-          rb_raise(rb_eEncodingError, "String is invalid UTF-8");
-        }
-      }
-
+      value = Convert_CheckStringUtf8(value);
       ret.str_val = Convert_StringData(value, arena);
       break;
-    }
     case kUpb_CType_Bytes: {
       VALUE bytes = rb_enc_from_encoding(rb_ascii8bit_encoding());
       if (rb_obj_class(value) != rb_cString) {
@@ -204,7 +228,8 @@ upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
           ret.uint64_val = NUM2ULL(value);
           break;
         default:
-          break;
+          rb_raise(cTypeError, "Convert_RubyToUpb(): Unexpected type %d",
+                   (int)type_info.type);
       }
       break;
     default:

data/ext/google/protobuf_c/defs.c

@@ -1510,7 +1510,7 @@ static VALUE MethodDescriptor_initialize(VALUE _self, VALUE cookie,
   }
 
   RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
-  self->methoddef = (const upb_ServiceDef*)NUM2ULL(ptr);
+  self->methoddef = (const upb_MethodDef*)NUM2ULL(ptr);
 
   return Qnil;
 }

data/ext/google/protobuf_c/map.c

@@ -63,9 +63,10 @@ static VALUE Map_alloc(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Map_type, self);
 }
 
-VALUE Map_GetRubyWrapper(upb_Map* map, upb_CType key_type, TypeInfo value_type,
-                         VALUE arena) {
+VALUE Map_GetRubyWrapper(const upb_Map* map, upb_CType key_type,
+                         TypeInfo value_type, VALUE arena) {
   PBRUBY_ASSERT(map);
+  PBRUBY_ASSERT(arena != Qnil);
 
   VALUE val = ObjectCache_Get(map);
 
@@ -83,7 +84,6 @@ VALUE Map_GetRubyWrapper(upb_Map* map, upb_CType key_type, TypeInfo value_type,
     }
     return ObjectCache_TryAdd(map, val);
   }
-
   return val;
 }
 
@@ -105,8 +105,9 @@ static TypeInfo Map_keyinfo(Map* self) {
 }
 
 static upb_Map* Map_GetMutable(VALUE _self) {
-  rb_check_frozen(_self);
-  return (upb_Map*)ruby_to_Map(_self)->map;
+  const upb_Map* map = ruby_to_Map(_self)->map;
+  Protobuf_CheckNotFrozen(_self, upb_Map_IsFrozen(map));
+  return (upb_Map*)map;
 }
 
 VALUE Map_CreateHash(const upb_Map* map, upb_CType key_type,
@@ -439,14 +440,14 @@ static VALUE Map_has_key(VALUE _self, VALUE key) {
  * nil if none was present. Throws an exception if the key is of the wrong type.
  */
 static VALUE Map_delete(VALUE _self, VALUE key) {
+  upb_Map* map = Map_GetMutable(_self);
   Map* self = ruby_to_Map(_self);
-  rb_check_frozen(_self);
 
   upb_MessageValue key_upb =
       Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
   upb_MessageValue val_upb;
 
-  if (upb_Map_Delete(Map_GetMutable(_self), key_upb, &val_upb)) {
+  if (upb_Map_Delete(map, key_upb, &val_upb)) {
     return Convert_UpbToRuby(val_upb, self->value_type_info, self->arena);
   } else {
     return Qnil;
@@ -560,29 +561,79 @@ VALUE Map_eq(VALUE _self, VALUE _other) {
 
 /*
  * call-seq:
- *     Message.freeze => self
+ *     Map.frozen? => bool
+ *
+ * Returns true if the map is frozen in either Ruby or the underlying
+ * representation. Freezes the Ruby map object if it is not already frozen in
+ * Ruby but it is frozen in the underlying representation.
+ */
+VALUE Map_frozen(VALUE _self) {
+  Map* self = ruby_to_Map(_self);
+  if (!upb_Map_IsFrozen(self->map)) {
+    PBRUBY_ASSERT(!RB_OBJ_FROZEN(_self));
+    return Qfalse;
+  }
+
+  // Lazily freeze the Ruby wrapper.
+  if (!RB_OBJ_FROZEN(_self)) RB_OBJ_FREEZE(_self);
+  return Qtrue;
+}
+
+/*
+ * call-seq:
+ *     Map.freeze => self
  *
- * Freezes the message object. We have to intercept this so we can pin the
- * Ruby object into memory so we don't forget it's frozen.
+ * Freezes the map object. We have to intercept this so we can freeze the
+ * underlying representation, not just the Ruby wrapper.
  */
 VALUE Map_freeze(VALUE _self) {
   Map* self = ruby_to_Map(_self);
+  if (RB_OBJ_FROZEN(_self)) {
+    PBRUBY_ASSERT(upb_Map_IsFrozen(self->map));
+    return _self;
+  }
+
+  if (!upb_Map_IsFrozen(self->map)) {
+    if (self->value_type_info.type == kUpb_CType_Message) {
+      upb_Map_Freeze(
+          Map_GetMutable(_self),
+          upb_MessageDef_MiniTable(self->value_type_info.def.msgdef));
+    } else {
+      upb_Map_Freeze(Map_GetMutable(_self), NULL);
+    }
+  }
 
-  if (RB_OBJ_FROZEN(_self)) return _self;
-  Arena_Pin(self->arena, _self);
   RB_OBJ_FREEZE(_self);
 
-  if (self->value_type_info.type == kUpb_CType_Message) {
-    size_t iter = kUpb_Map_Begin;
-    upb_MessageValue key, val;
+  return _self;
+}
+
+VALUE Map_EmptyFrozen(const upb_FieldDef* f) {
+  PBRUBY_ASSERT(upb_FieldDef_IsMap(f));
+  VALUE val = ObjectCache_Get(f);
 
-    while (upb_Map_Next(self->map, &key, &val, &iter)) {
-      VALUE val_val =
-          Convert_UpbToRuby(val, self->value_type_info, self->arena);
-      Message_freeze(val_val);
+  if (val == Qnil) {
+    const upb_FieldDef* key_f = map_field_key(f);
+    const upb_FieldDef* val_f = map_field_value(f);
+    upb_CType key_type = upb_FieldDef_CType(key_f);
+    TypeInfo value_type_info = TypeInfo_get(val_f);
+    val = Map_alloc(cMap);
+    Map* self;
+    TypedData_Get_Struct(val, Map, &Map_type, self);
+    self->arena = Arena_new();
+    self->map =
+        upb_Map_New(Arena_get(self->arena), key_type, value_type_info.type);
+    self->key_type = key_type;
+    self->value_type_info = value_type_info;
+    if (self->value_type_info.type == kUpb_CType_Message) {
+      const upb_MessageDef* val_m = value_type_info.def.msgdef;
+      self->value_type_class = Descriptor_DefToClass(val_m);
     }
+    return ObjectCache_TryAdd(f, Map_freeze(val));
   }
-  return _self;
+  PBRUBY_ASSERT(RB_OBJ_FROZEN(val));
+  PBRUBY_ASSERT(upb_Map_IsFrozen(ruby_to_Map(val)->map));
+  return val;
 }
 
 /*
@@ -671,6 +722,7 @@ void Map_register(VALUE module) {
   rb_define_method(klass, "clone", Map_dup, 0);
   rb_define_method(klass, "==", Map_eq, 1);
   rb_define_method(klass, "freeze", Map_freeze, 0);
+  rb_define_method(klass, "frozen?", Map_frozen, 0);
   rb_define_method(klass, "hash", Map_hash, 0);
   rb_define_method(klass, "to_h", Map_to_h, 0);
   rb_define_method(klass, "inspect", Map_inspect, 0);

data/ext/google/protobuf_c/map.h

@@ -11,10 +11,14 @@
 #include "protobuf.h"
 #include "ruby-upb.h"
 
+// Returns a frozen sentinel Ruby wrapper object for an empty upb_Map with the
+// key and value types specified by the field. Creates one if it doesn't exist.
+VALUE Map_EmptyFrozen(const upb_FieldDef* f);
+
 // Returns a Ruby wrapper object for the given map, which will be created if
 // one does not exist already.
-VALUE Map_GetRubyWrapper(upb_Map *map, upb_CType key_type, TypeInfo value_type,
-                         VALUE arena);
+VALUE Map_GetRubyWrapper(const upb_Map *map, upb_CType key_type,
+                         TypeInfo value_type, VALUE arena);
 
 // Gets the underlying upb_Map for this Ruby map object, which must have
 // key/value type that match |field|. If this is not a map or the type doesn't

data/ext/google/protobuf_c/message.c

@@ -80,11 +80,13 @@ const upb_Message* Message_Get(VALUE msg_rb, const upb_MessageDef** m) {
 }
 
 upb_Message* Message_GetMutable(VALUE msg_rb, const upb_MessageDef** m) {
-  rb_check_frozen(msg_rb);
-  return (upb_Message*)Message_Get(msg_rb, m);
+  const upb_Message* upb_msg = Message_Get(msg_rb, m);
+  Protobuf_CheckNotFrozen(msg_rb, upb_Message_IsFrozen(upb_msg));
+  return (upb_Message*)upb_msg;
 }
 
-void Message_InitPtr(VALUE self_, upb_Message* msg, VALUE arena) {
+void Message_InitPtr(VALUE self_, const upb_Message* msg, VALUE arena) {
+  PBRUBY_ASSERT(arena != Qnil);
   Message* self = ruby_to_Message(self_);
   self->msg = msg;
   RB_OBJ_WRITE(self_, &self->arena, arena);
@@ -105,7 +107,7 @@ void Message_CheckClass(VALUE klass) {
   }
 }
 
-VALUE Message_GetRubyWrapper(upb_Message* msg, const upb_MessageDef* m,
+VALUE Message_GetRubyWrapper(const upb_Message* msg, const upb_MessageDef* m,
                              VALUE arena) {
   if (msg == NULL) return Qnil;
 
@@ -116,7 +118,6 @@ VALUE Message_GetRubyWrapper(upb_Message* msg, const upb_MessageDef* m,
     val = Message_alloc(klass);
     Message_InitPtr(val, msg, arena);
   }
-
   return val;
 }
 
@@ -248,7 +249,7 @@ static int extract_method_call(VALUE method_name, Message* self,
 static VALUE Message_oneof_accessor(VALUE _self, const upb_OneofDef* o,
                                     int accessor_type) {
   Message* self = ruby_to_Message(_self);
-  const upb_FieldDef* oneof_field = upb_Message_WhichOneof(self->msg, o);
+  const upb_FieldDef* oneof_field = upb_Message_WhichOneofByDef(self->msg, o);
 
   switch (accessor_type) {
     case METHOD_PRESENCE:
@@ -288,13 +289,42 @@ static void Message_setfield(upb_Message* msg, const upb_FieldDef* f, VALUE val,
   upb_Message_SetFieldByDef(msg, f, msgval, arena);
 }
 
+VALUE Message_getfield_frozen(const upb_Message* msg, const upb_FieldDef* f,
+                              VALUE arena) {
+  upb_MessageValue msgval = upb_Message_GetFieldByDef(msg, f);
+  if (upb_FieldDef_IsMap(f)) {
+    if (msgval.map_val == NULL) {
+      return Map_EmptyFrozen(f);
+    }
+    const upb_FieldDef* key_f = map_field_key(f);
+    const upb_FieldDef* val_f = map_field_value(f);
+    upb_CType key_type = upb_FieldDef_CType(key_f);
+    TypeInfo value_type_info = TypeInfo_get(val_f);
+    return Map_GetRubyWrapper(msgval.map_val, key_type, value_type_info, arena);
+  }
+  if (upb_FieldDef_IsRepeated(f)) {
+    if (msgval.array_val == NULL) {
+      return RepeatedField_EmptyFrozen(f);
+    }
+    return RepeatedField_GetRubyWrapper(msgval.array_val, TypeInfo_get(f),
+                                        arena);
+  }
+  VALUE ret;
+  if (upb_FieldDef_IsSubMessage(f)) {
+    const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
+    ret = Message_GetRubyWrapper(msgval.msg_val, m, arena);
+  } else {
+    ret = Convert_UpbToRuby(msgval, TypeInfo_get(f), Qnil);
+  }
+  return ret;
+}
+
 VALUE Message_getfield(VALUE _self, const upb_FieldDef* f) {
   Message* self = ruby_to_Message(_self);
-  // This is a special-case: upb_Message_Mutable() for map & array are logically
-  // const (they will not change what is serialized) but physically
-  // non-const, as they do allocate a repeated field or map. The logical
-  // constness means it's ok to do even if the message is frozen.
-  upb_Message* msg = (upb_Message*)self->msg;
+  if (upb_Message_IsFrozen(self->msg)) {
+    return Message_getfield_frozen(self->msg, f, self->arena);
+  }
+  upb_Message* msg = Message_GetMutable(_self, NULL);
   upb_Arena* arena = Arena_get(self->arena);
   if (upb_FieldDef_IsMap(f)) {
     upb_Map* map = upb_Message_Mutable(msg, f, arena).map;
@@ -307,12 +337,12 @@ VALUE Message_getfield(VALUE _self, const upb_FieldDef* f) {
     upb_Array* arr = upb_Message_Mutable(msg, f, arena).array;
     return RepeatedField_GetRubyWrapper(arr, TypeInfo_get(f), self->arena);
   } else if (upb_FieldDef_IsSubMessage(f)) {
-    if (!upb_Message_HasFieldByDef(self->msg, f)) return Qnil;
+    if (!upb_Message_HasFieldByDef(msg, f)) return Qnil;
     upb_Message* submsg = upb_Message_Mutable(msg, f, arena).msg;
     const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
     return Message_GetRubyWrapper(submsg, m, self->arena);
   } else {
-    upb_MessageValue msgval = upb_Message_GetFieldByDef(self->msg, f);
+    upb_MessageValue msgval = upb_Message_GetFieldByDef(msg, f);
     return Convert_UpbToRuby(msgval, TypeInfo_get(f), self->arena);
   }
 }
@@ -436,7 +466,6 @@ static VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self) {
       if (argc != 2) {
         rb_raise(rb_eArgError, "Expected 2 arguments, received %d", argc);
       }
-      rb_check_frozen(_self);
       break;
     default:
       if (argc != 1) {
@@ -812,33 +841,42 @@ static VALUE Message_to_h(VALUE _self) {
 
 /*
  * call-seq:
- *     Message.freeze => self
+ *     Message.frozen? => bool
  *
- * Freezes the message object. 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 message is frozen in either Ruby or the underlying
+ * representation. Freezes the Ruby message object if it is not already frozen
+ * in Ruby but it is frozen in the underlying representation.
  */
-VALUE Message_freeze(VALUE _self) {
+VALUE Message_frozen(VALUE _self) {
   Message* self = ruby_to_Message(_self);
+  if (!upb_Message_IsFrozen(self->msg)) {
+    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;
+}
 
-  int n = upb_MessageDef_FieldCount(self->msgdef);
-  for (int i = 0; i < n; i++) {
-    const upb_FieldDef* f = upb_MessageDef_Field(self->msgdef, i);
-    VALUE field = Message_getfield(_self, f);
-
-    if (field != Qnil) {
-      if (upb_FieldDef_IsMap(f)) {
-        Map_freeze(field);
-      } else if (upb_FieldDef_IsRepeated(f)) {
-        RepeatedField_freeze(field);
-      } else if (upb_FieldDef_IsSubMessage(f)) {
-        Message_freeze(field);
-      }
-    }
+/*
+ * call-seq:
+ *     Message.freeze => self
+ *
+ * Freezes the message object. We have to intercept this so we can freeze the
+ * underlying representation, not just the Ruby wrapper.
+ */
+VALUE Message_freeze(VALUE _self) {
+  Message* self = ruby_to_Message(_self);
+  if (RB_OBJ_FROZEN(_self)) {
+    PBRUBY_ASSERT(upb_Message_IsFrozen(self->msg));
+    return _self;
   }
+  if (!upb_Message_IsFrozen(self->msg)) {
+    upb_Message_Freeze(Message_GetMutable(_self, NULL),
+                       upb_MessageDef_MiniTable(self->msgdef));
+  }
+  RB_OBJ_FREEZE(_self);
   return _self;
 }
 
@@ -1352,6 +1390,7 @@ static void Message_define_class(VALUE klass) {
   rb_define_method(klass, "==", Message_eq, 1);
   rb_define_method(klass, "eql?", Message_eq, 1);
   rb_define_method(klass, "freeze", Message_freeze, 0);
+  rb_define_method(klass, "frozen?", Message_frozen, 0);
   rb_define_method(klass, "hash", Message_hash, 0);
   rb_define_method(klass, "to_h", Message_to_h, 0);
   rb_define_method(klass, "inspect", Message_inspect, 0);

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.

data/ext/google/protobuf_c/protobuf.c

@@ -221,15 +221,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);
@@ -354,3 +345,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

@@ -50,13 +50,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,6 +98,9 @@ extern VALUE cTypeError;
   rb_bug("Assertion failed at %s:%d, expr: %s", __FILE__, __LINE__, #expr)
 #endif
 
+// Raises a Ruby error if val is frozen in Ruby or upb_frozen is true.
+void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen);
+
 #define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y))
 
 #define UPB_UNUSED(var) (void)var

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;
 }
 
@@ -471,29 +494,49 @@ VALUE RepeatedField_eq(VALUE _self, VALUE _other) {
   return Qtrue;
 }
 
+/*
+ * call-seq:
+ *     RepeatedField.frozen? => bool
+ *
+ * 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.
+ */
+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;
+  }
+
+  // Lazily freeze the Ruby wrapper.
+  if (!RB_OBJ_FROZEN(_self)) RB_OBJ_FREEZE(_self);
+  return Qtrue;
+}
+
 /*
  * call-seq:
  *     RepeatedField.freeze => self
  *
- * 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.
+ * Freezes the repeated field object. We have to intercept this so we can freeze
+ * the underlying representation, not just the Ruby wrapper.
  */
 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 (RB_OBJ_FROZEN(_self)) return _self;
-  Arena_Pin(self->arena, _self);
-  RB_OBJ_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_freeze(val);
+  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;
 }
 
@@ -640,6 +683,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