google-protobuf 4.36.2-java → 4.37.0.rc.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45ff720d519c7b536a3fa27f6a141cff023010b405e5ab2cfd9c2a510562e500
-  data.tar.gz: 856019695a1ab061f54ed34c0c801ad15592e477204dfb3ed7505ad81e9273e1
+  metadata.gz: 2cff40a754cba2763c4bdd5bac2ea7ed53266991c7ba26d985d79f34b2d99e3d
+  data.tar.gz: 0cd3f1806abab5b5a62390493debb96d66bbd05c6e0521dc379c516cb0466a9e
 SHA512:
-  metadata.gz: 74acc1f8c637b6c6506901492820cbae8388e23a1619b12d2bd3d06bd84e73b6979902e297f1b478c0f8fbf8bdf13576efbf8e3463a065b7076bfe93391541e1
-  data.tar.gz: 2c1b18cf842df0592fdcf7be6b109c54716efbf4f500e779c44b261e50e837839892564f04333efe214c9ec484c60a7b70b78d4039b7be8c5c027c896f8e8a14
+  metadata.gz: 973a8163db63fa331207141ef170cba75abab4d1ed4d558c64d95929994e5561fe3acab7a712a0de036a64f8c834a37801a3194a6128503dd4ea459eecefd546
+  data.tar.gz: 54067bee74a01cbe063ac6c534d4b2c9c2ff4bdf45cc74bc8be47310f5847f19cb36931455680e424165763524c1ad8ef4acc003775183bb88749372818af859

data/ext/google/protobuf_c/message.c

@@ -286,7 +286,9 @@ static void Message_setfield(upb_Message* msg, const upb_FieldDef* f, VALUE val,
     msgval =
         Convert_RubyToUpb(val, upb_FieldDef_Name(f), TypeInfo_get(f), arena);
   }
-  upb_Message_SetFieldByDef(msg, f, msgval, arena);
+  if (!upb_Message_SetFieldByDef(msg, f, msgval, arena)) {
+    Arena_raise_oom();
+  }
 }
 
 VALUE Message_getfield_frozen(const upb_Message* msg, const upb_FieldDef* f,
@@ -328,6 +330,7 @@ VALUE Message_getfield(VALUE _self, const upb_FieldDef* f) {
   upb_Arena* arena = Arena_get(self->arena);
   if (upb_FieldDef_IsMap(f)) {
     upb_Map* map = upb_Message_Mutable(msg, f, arena).map;
+    if (!map) Arena_raise_oom();
     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);
@@ -335,10 +338,12 @@ VALUE Message_getfield(VALUE _self, const upb_FieldDef* f) {
     return Map_GetRubyWrapper(map, key_type, value_type_info, self->arena);
   } else if (upb_FieldDef_IsRepeated(f)) {
     upb_Array* arr = upb_Message_Mutable(msg, f, arena).array;
+    if (!arr) Arena_raise_oom();
     return RepeatedField_GetRubyWrapper(arr, TypeInfo_get(f), self->arena);
   } else if (upb_FieldDef_IsSubMessage(f)) {
     if (!upb_Message_HasFieldByDef(msg, f)) return Qnil;
     upb_Message* submsg = upb_Message_Mutable(msg, f, arena).msg;
+    if (!submsg) Arena_raise_oom();
     const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
     return Message_GetRubyWrapper(submsg, m, self->arena);
   } else {
@@ -390,7 +395,10 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
         upb_MessageValue msgval = Convert_RubyToUpb(
             argv[1], upb_FieldDef_Name(f), TypeInfo_get(val_f), arena);
         upb_Message* wrapper = upb_Message_Mutable(msg, f, arena).msg;
-        upb_Message_SetFieldByDef(wrapper, val_f, msgval, arena);
+        if (!wrapper) Arena_raise_oom();
+        if (!upb_Message_SetFieldByDef(wrapper, val_f, msgval, arena)) {
+          Arena_raise_oom();
+        }
       }
       return Qnil;
     }
@@ -519,19 +527,25 @@ typedef struct {
 static int Map_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
   MapInit* map_init = (MapInit*)_self;
   upb_MessageValue k, v;
-  k = Convert_RubyToUpb(key, "", map_init->key_type, NULL);
+  // Copy the key into the arena rather than aliasing it: building the value
+  // below allocates, which can trigger GC and free or move the String the key
+  // would otherwise point into.
+  k = Convert_RubyToUpb(key, "", map_init->key_type, map_init->arena);
 
   if (map_init->val_type.type == kUpb_CType_Message && TYPE(val) == T_HASH) {
     const upb_MiniTable* t =
         upb_MessageDef_MiniTable(map_init->val_type.def.msgdef);
     upb_Message* msg = upb_Message_New(t, map_init->arena);
+    if (!msg) Arena_raise_oom();
     Message_InitFromValue(msg, map_init->val_type.def.msgdef, val,
                           map_init->arena);
     v.msg_val = msg;
   } else {
     v = Convert_RubyToUpb(val, "", map_init->val_type, map_init->arena);
   }
-  upb_Map_Set(map_init->map, k, v, map_init->arena);
+  if (!upb_Map_Set(map_init->map, k, v, map_init->arena)) {
+    Arena_raise_oom();
+  }
   return ST_CONTINUE;
 }
 
@@ -556,6 +570,7 @@ static upb_MessageValue MessageValue_FromValue(VALUE val, TypeInfo info,
     upb_MessageValue msgval;
     const upb_MiniTable* t = upb_MessageDef_MiniTable(info.def.msgdef);
     upb_Message* msg = upb_Message_New(t, arena);
+    if (!msg) Arena_raise_oom();
     Message_InitFromValue(msg, info.def.msgdef, val, arena);
     msgval.msg_val = msg;
     return msgval;
@@ -583,7 +598,9 @@ static void RepeatedField_InitFromValue(upb_Array* arr, const upb_FieldDef* f,
     } else {
       msgval = Convert_RubyToUpb(entry, upb_FieldDef_Name(f), type_info, arena);
     }
-    upb_Array_Append(arr, msgval, arena);
+    if (!upb_Array_Append(arr, msgval, arena)) {
+      Arena_raise_oom();
+    }
   }
 }
 
@@ -593,13 +610,16 @@ static void Message_InitFieldFromValue(upb_Message* msg, const upb_FieldDef* f,
 
   if (upb_FieldDef_IsMap(f)) {
     upb_Map* map = upb_Message_Mutable(msg, f, arena).map;
+    if (!map) Arena_raise_oom();
     Map_InitFromValue(map, f, val, arena);
   } else if (upb_FieldDef_IsRepeated(f)) {
     upb_Array* arr = upb_Message_Mutable(msg, f, arena).array;
+    if (!arr) Arena_raise_oom();
     RepeatedField_InitFromValue(arr, f, val, arena);
   } else if (upb_FieldDef_IsSubMessage(f)) {
     if (TYPE(val) == T_HASH) {
       upb_Message* submsg = upb_Message_Mutable(msg, f, arena).msg;
+      if (!submsg) Arena_raise_oom();
       Message_InitFromValue(submsg, upb_FieldDef_MessageSubDef(f), val, arena);
     } else {
       Message_setfield(msg, f, val, arena);
@@ -607,7 +627,9 @@ static void Message_InitFieldFromValue(upb_Message* msg, const upb_FieldDef* f,
   } else {
     upb_MessageValue msgval =
         Convert_RubyToUpb(val, upb_FieldDef_Name(f), TypeInfo_get(f), arena);
-    upb_Message_SetFieldByDef(msg, f, msgval, arena);
+    if (!upb_Message_SetFieldByDef(msg, f, msgval, arena)) {
+      Arena_raise_oom();
+    }
   }
 }
 
@@ -668,6 +690,7 @@ static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
   upb_Arena* arena = Arena_get(arena_rb);
   const upb_MiniTable* t = upb_MessageDef_MiniTable(self->msgdef);
   upb_Message* msg = upb_Message_New(t, arena);
+  if (!msg) Arena_raise_oom();
 
   Message_InitPtr(_self, msg, arena_rb);
 
@@ -733,6 +756,9 @@ uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
   if (upb_Status_IsOk(&status)) {
     return return_value;
   } else {
+    if (strcmp(upb_Status_ErrorMessage(&status), "Out of memory") == 0) {
+      Arena_raise_oom();
+    }
     rb_raise(cParseError, "Message_Hash(): %s",
              upb_Status_ErrorMessage(&status));
   }
@@ -774,25 +800,64 @@ static VALUE Message_inspect(VALUE _self) {
 
 // Support functions for Message_to_h //////////////////////////////////////////
 
-static VALUE RepeatedField_CreateArray(const upb_Array* arr,
-                                       TypeInfo type_info) {
+static VALUE RepeatedField_CreateArray(const upb_Array* arr, TypeInfo type_info,
+                                       bool emit_defaults) {
   int size = arr ? upb_Array_Size(arr) : 0;
   VALUE ary = rb_ary_new2(size);
 
   for (int i = 0; i < size; i++) {
     upb_MessageValue msgval = upb_Array_Get(arr, i);
-    VALUE val = Scalar_CreateHash(msgval, type_info);
+    VALUE val = Scalar_CreateHash(msgval, type_info, emit_defaults);
     rb_ary_push(ary, val);
   }
 
   return ary;
 }
 
-static VALUE Message_CreateHash(const upb_Message* msg,
-                                const upb_MessageDef* m) {
+static VALUE Message_CreateHash(const upb_Message* msg, const upb_MessageDef* m,
+                                bool emit_defaults) {
   if (!msg) return Qnil;
 
   VALUE hash = rb_hash_new();
+
+  if (emit_defaults) {
+    int n = upb_MessageDef_FieldCount(m);
+
+    for (int i = 0; i < n; i++) {
+      const upb_FieldDef* field = upb_MessageDef_Field(m, i);
+
+      if (upb_FieldDef_HasPresence(field) &&
+          !upb_Message_HasFieldByDef(msg, field)) {
+        continue;
+      }
+
+      TypeInfo type_info = TypeInfo_get(field);
+      upb_MessageValue val = upb_Message_GetFieldByDef(msg, field);
+      VALUE msg_value;
+
+      if (upb_FieldDef_IsMap(field)) {
+        const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(field);
+        const upb_FieldDef* key_f =
+            upb_MessageDef_FindFieldByNumber(entry_m, 1);
+        const upb_FieldDef* val_f =
+            upb_MessageDef_FindFieldByNumber(entry_m, 2);
+        upb_CType key_type = upb_FieldDef_CType(key_f);
+        msg_value = Map_CreateHash(val.map_val, key_type, TypeInfo_get(val_f),
+                                   emit_defaults);
+      } else if (upb_FieldDef_IsRepeated(field)) {
+        msg_value =
+            RepeatedField_CreateArray(val.array_val, type_info, emit_defaults);
+      } else {
+        msg_value = Scalar_CreateHash(val, type_info, emit_defaults);
+      }
+
+      VALUE msg_key = ID2SYM(rb_intern(upb_FieldDef_Name(field)));
+      rb_hash_aset(hash, msg_key, msg_value);
+    }
+
+    return hash;
+  }
+
   size_t iter = kUpb_Message_Begin;
   const upb_DefPool* pool = upb_FileDef_Pool(upb_MessageDef_File(m));
   const upb_FieldDef* field;
@@ -813,11 +878,13 @@ static VALUE Message_CreateHash(const upb_Message* msg,
       const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry_m, 1);
       const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
       upb_CType key_type = upb_FieldDef_CType(key_f);
-      msg_value = Map_CreateHash(val.map_val, key_type, TypeInfo_get(val_f));
+      msg_value = Map_CreateHash(val.map_val, key_type, TypeInfo_get(val_f),
+                                 emit_defaults);
     } else if (upb_FieldDef_IsRepeated(field)) {
-      msg_value = RepeatedField_CreateArray(val.array_val, type_info);
+      msg_value =
+          RepeatedField_CreateArray(val.array_val, type_info, emit_defaults);
     } else {
-      msg_value = Scalar_CreateHash(val, type_info);
+      msg_value = Scalar_CreateHash(val, type_info, emit_defaults);
     }
 
     VALUE msg_key = ID2SYM(rb_intern(upb_FieldDef_Name(field)));
@@ -827,9 +894,11 @@ static VALUE Message_CreateHash(const upb_Message* msg,
   return hash;
 }
 
-VALUE Scalar_CreateHash(upb_MessageValue msgval, TypeInfo type_info) {
+VALUE Scalar_CreateHash(upb_MessageValue msgval, TypeInfo type_info,
+                        bool emit_defaults) {
   if (type_info.type == kUpb_CType_Message) {
-    return Message_CreateHash(msgval.msg_val, type_info.def.msgdef);
+    return Message_CreateHash(msgval.msg_val, type_info.def.msgdef,
+                              emit_defaults);
   } else {
     return Convert_UpbToRuby(msgval, type_info, Qnil);
   }
@@ -840,11 +909,49 @@ VALUE Scalar_CreateHash(upb_MessageValue msgval, TypeInfo type_info) {
  *
  * Returns the message as a Ruby Hash object, with keys as symbols.
  *
+ * By default, only fields that are present are included. A field without
+ * presence (an implicit presence scalar or enum, or a repeated or map field)
+ * counts as present only when it holds a non-default value or is non-empty.
+ *
+ * +emit_defaults+ does not emit a default value for every field. It only
+ * additionally includes the fields that have no presence, using their default
+ * values (for example 0, "" or false, and empty arrays and hashes for repeated
+ * and map fields). This is the ProtoJSON "always emit fields without presence"
+ * option, called +always_print_fields_with_no_presence+ in C++ and Python.
+ *
+ * Fields that have presence are never added by +emit_defaults+ and are
+ * included only when they are set: singular message fields, fields in a
+ * oneof, and fields with explicit presence such as proto3 +optional+ fields
+ * and proto2 singular fields. To include one of these, set it explicitly.
+ *
+ * The option applies recursively, including to messages in repeated fields
+ * and map values. It selects the same fields as #inspect and as .encode_json
+ * with +emit_defaults+.
+ *
+ * @param kwargs [Hash]
+ * @option emit_defaults [Boolean] set true to also include fields that have
+ * no presence, with their default values (default is false). Fields that have
+ * presence are not affected.
  * @return [Hash]
  */
-static VALUE Message_to_h(VALUE _self) {
+static VALUE Message_to_h(int argc, VALUE* argv, VALUE _self) {
   Message* self = ruby_to_Message(_self);
-  return Message_CreateHash(self->msg, self->msgdef);
+  VALUE kwargs = Qnil;
+  bool emit_defaults = false;
+
+  rb_scan_args_kw(RB_SCAN_ARGS_PASS_CALLED_KEYWORDS, argc, argv, ":", &kwargs);
+
+  if (!NIL_P(kwargs)) {
+    ID keyword_ids[1];
+    VALUE values[1];
+    keyword_ids[0] = rb_intern("emit_defaults");
+    rb_get_kwargs(kwargs, keyword_ids, 0, 1, values);
+    if (values[0] != Qundef) {
+      emit_defaults = RTEST(values[0]);
+    }
+  }
+
+  return Message_CreateHash(self->msg, self->msgdef, emit_defaults);
 }
 
 /*
@@ -937,8 +1044,10 @@ static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
   }
 
   val = Convert_RubyToUpb(value, upb_FieldDef_Name(f), TypeInfo_get(f), arena);
-  upb_Message_SetFieldByDef(Message_GetMutable(_self, NULL), f, val, arena);
-
+  if (!upb_Message_SetFieldByDef(Message_GetMutable(_self, NULL), f, val,
+                                 arena)) {
+    Arena_raise_oom();
+  }
   return Qnil;
 }
 
@@ -995,6 +1104,9 @@ VALUE Message_decode_bytes(size_t size, const char* bytes, int options,
   upb_DecodeStatus status = upb_Decode(bytes, size, (upb_Message*)msg->msg,
                                        upb_MessageDef_MiniTable(msg->msgdef),
                                        extreg, options, Arena_get(msg->arena));
+  if (status == kUpb_DecodeStatus_OutOfMemory) {
+    Arena_raise_oom();
+  }
   if (status != kUpb_DecodeStatus_Ok) {
     rb_raise(cParseError, "Error occurred during parsing");
   }
@@ -1064,10 +1176,18 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
   switch (result) {
     case kUpb_JsonDecodeResult_Ok:
       break;
-    case kUpb_JsonDecodeResult_Error:
+    case kUpb_JsonDecodeResult_Error: {
+      VALUE pending_err = rb_errinfo();
+      if (!NIL_P(pending_err)) {
+        rb_set_errinfo(Qnil);
+        rb_exc_raise(pending_err);
+      }
+
       rb_raise(cParseError, "Error occurred during parsing: %s",
                upb_Status_ErrorMessage(&status));
+
       break;
+    }
   }
 
   return msg_rb;
@@ -1113,6 +1233,9 @@ static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
   }
 
   upb_Arena* arena = upb_Arena_New();
+  if (!arena) {
+    Arena_raise_oom();
+  }
 
   upb_EncodeStatus status =
       upb_Encode(msg->msg, upb_MessageDef_MiniTable(msg->msgdef), options,
@@ -1123,10 +1246,18 @@ static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
     rb_enc_associate(ret, rb_ascii8bit_encoding());
     upb_Arena_Free(arena);
     return ret;
-  } else {
-    upb_Arena_Free(arena);
+  }
+  upb_Arena_Free(arena);
+  if (status == kUpb_EncodeStatus_OutOfMemory) {
+    Arena_raise_oom();
+  }
+  if (status == kUpb_EncodeStatus_MaxDepthExceeded) {
     rb_raise(rb_eRuntimeError, "Exceeded maximum depth (possibly cycle)");
   }
+  if (status == kUpb_EncodeStatus_MaxSizeExceeded) {
+    rb_raise(rb_eRuntimeError, "Exceeded maximum size");
+  }
+  rb_raise(cParseError, "Unknown encoding error");
 }
 
 /*
@@ -1138,8 +1269,10 @@ static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
  * @param options [Hash]
  * @option preserve_proto_fieldnames [Boolean] set true to use original
  * fieldnames (default is to camelCase)
- * @option emit_defaults [Boolean] set true to emit 0/false values (default is
- * to omit them)
+ * @option emit_defaults [Boolean] set true to also emit fields that have no
+ * presence, with their default values (default is to omit them). Fields that
+ * have presence, such as message fields, oneof fields and +optional+ fields,
+ * are emitted only when set. See #to_h.
  * @return [String]
  */
 static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
@@ -1310,9 +1443,15 @@ VALUE build_module_from_enumdesc(VALUE _enumdesc) {
   int n = upb_EnumDef_ValueCount(e);
   for (int i = 0; i < n; i++) {
     const upb_EnumValueDef* ev = upb_EnumDef_Value(e, i);
-    upb_Arena* arena = upb_Arena_New();
     const char* src_name = upb_EnumValueDef_Name(ev);
-    char* name = upb_strdup2(src_name, strlen(src_name), arena);
+    size_t len = strlen(src_name);
+    upb_Arena* arena = upb_Arena_NewSized(len);
+    if (!arena) Arena_raise_oom();
+    char* name = upb_strdup2(src_name, len, arena);
+    if (!name) {
+      upb_Arena_Free(arena);
+      Arena_raise_oom();
+    }
     int32_t value = upb_EnumValueDef_Number(ev);
     if (name[0] < 'A' || name[0] > 'Z') {
       if (name[0] >= 'a' && name[0] <= 'z') {
@@ -1341,21 +1480,40 @@ upb_Message* Message_deep_copy(const upb_Message* msg, const upb_MessageDef* m,
                                upb_Arena* arena) {
   // Serialize and parse.
   upb_Arena* tmp_arena = upb_Arena_New();
+  if (!tmp_arena) {
+    Arena_raise_oom();
+  }
   const upb_MiniTable* layout = upb_MessageDef_MiniTable(m);
   size_t size;
 
   upb_Message* new_msg = upb_Message_New(layout, arena);
+  if (!new_msg) {
+    upb_Arena_Free(tmp_arena);
+    Arena_raise_oom();
+  }
   char* data;
 
   const upb_FileDef* file = upb_MessageDef_File(m);
   const upb_ExtensionRegistry* extreg =
       upb_DefPool_ExtensionRegistry(upb_FileDef_Pool(file));
-  if (upb_Encode(msg, layout, 0, tmp_arena, &data, &size) !=
-          kUpb_EncodeStatus_Ok ||
-      upb_Decode(data, size, new_msg, layout, extreg, 0, arena) !=
-          kUpb_DecodeStatus_Ok) {
+  upb_EncodeStatus encode_status =
+      upb_Encode(msg, layout, 0, tmp_arena, &data, &size);
+  if (encode_status == kUpb_EncodeStatus_OutOfMemory) {
+    upb_Arena_Free(tmp_arena);
+    Arena_raise_oom();
+  } else if (encode_status != kUpb_EncodeStatus_Ok) {
     upb_Arena_Free(tmp_arena);
-    rb_raise(cParseError, "Error occurred copying proto");
+    rb_raise(cParseError, "Error occurred copying proto during encode");
+  }
+
+  upb_DecodeStatus decode_status =
+      upb_Decode(data, size, new_msg, layout, extreg, 0, arena);
+  if (decode_status == kUpb_DecodeStatus_OutOfMemory) {
+    upb_Arena_Free(tmp_arena);
+    Arena_raise_oom();
+  } else if (decode_status != kUpb_DecodeStatus_Ok) {
+    upb_Arena_Free(tmp_arena);
+    rb_raise(cParseError, "Error occurred copying proto during decode");
   }
 
   upb_Arena_Free(tmp_arena);
@@ -1392,8 +1550,10 @@ const upb_Message* Message_GetUpbMessage(VALUE value, const upb_MessageDef* m,
         time = rb_time_timespec(value);
         sec.int64_val = time.tv_sec;
         nsec.int32_val = time.tv_nsec;
-        upb_Message_SetFieldByDef(msg, sec_f, sec, arena);
-        upb_Message_SetFieldByDef(msg, nsec_f, nsec, arena);
+        if (!upb_Message_SetFieldByDef(msg, sec_f, sec, arena) ||
+            !upb_Message_SetFieldByDef(msg, nsec_f, nsec, arena)) {
+          Arena_raise_oom();
+        }
         return msg;
       }
       case kUpb_WellKnown_Duration: {
@@ -1408,8 +1568,10 @@ const upb_Message* Message_GetUpbMessage(VALUE value, const upb_MessageDef* m,
 
         sec.int64_val = NUM2LL(value);
         nsec.int32_val = round((NUM2DBL(value) - NUM2LL(value)) * 1000000000);
-        upb_Message_SetFieldByDef(msg, sec_f, sec, arena);
-        upb_Message_SetFieldByDef(msg, nsec_f, nsec, arena);
+        if (!upb_Message_SetFieldByDef(msg, sec_f, sec, arena) ||
+            !upb_Message_SetFieldByDef(msg, nsec_f, nsec, arena)) {
+          Arena_raise_oom();
+        }
         return msg;
       }
       default:
@@ -1442,7 +1604,7 @@ static void Message_define_class(VALUE klass) {
   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, "to_h", Message_to_h, -1);
   rb_define_method(klass, "inspect", Message_inspect, 0);
   rb_define_method(klass, "to_s", Message_inspect, 0);
   rb_define_method(klass, "[]", Message_index, 1);

data/ext/google/protobuf_c/message.h

@@ -58,7 +58,8 @@ upb_Message* Message_deep_copy(const upb_Message* msg, const upb_MessageDef* m,
 void Message_CheckClass(VALUE klass);
 
 // Returns a new Hash object containing the contents of this message.
-VALUE Scalar_CreateHash(upb_MessageValue val, TypeInfo type_info);
+VALUE Scalar_CreateHash(upb_MessageValue val, TypeInfo type_info,
+                        bool emit_defaults);
 
 // Creates a message class or enum module for this descriptor, respectively.
 VALUE build_class_from_descriptor(VALUE descriptor);

data/ext/google/protobuf_c/protobuf.c

@@ -182,23 +182,59 @@ const rb_data_type_t Arena_type = {
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
+struct ruby_upb_xrealloc_args {
+  void* ptr;
+  size_t size;
+};
+
+static VALUE safe_xrealloc_wrapper(VALUE arg) {
+  struct ruby_upb_xrealloc_args* args = (struct ruby_upb_xrealloc_args*)arg;
+
+  // If xrealloc fails, it will longjmp out of this function immediately.
+  // If it succeeds, we return the pointer cast as a VALUE.
+  void* new_ptr = xrealloc(args->ptr, args->size);
+  return (VALUE)new_ptr;
+}
+
 static void* ruby_upb_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize,
                                 size_t size, size_t* actual_size) {
   if (size == 0) {
     xfree(ptr);
     return NULL;
   } else {
-    return xrealloc(ptr, size);
+    struct ruby_upb_xrealloc_args args = {ptr, size};
+    int state = 0;
+
+    void* new_ptr =
+        (void*)rb_protect(safe_xrealloc_wrapper, (VALUE)&args, &state);
+
+    // Exception caught, but rb_errinfo still has the original error for
+    // consumption by the caller
+    return state ? NULL : new_ptr;
   }
 }
 
 upb_alloc ruby_upb_alloc = {&ruby_upb_allocfunc};
 
+void Arena_raise_oom() {
+  VALUE pending_err = rb_errinfo();
+  if (!NIL_P(pending_err)) {
+    rb_set_errinfo(Qnil);
+    rb_exc_raise(pending_err);
+  }
+  rb_raise(rb_eNoMemError, "Failed to allocate arena.");
+}
+
 static VALUE Arena_alloc(VALUE klass) {
-  Arena* arena = ALLOC(Arena);
-  arena->arena = upb_Arena_Init(NULL, 0, &ruby_upb_alloc);
-  arena->pinned_objs = Qnil;
-  return TypedData_Wrap_Struct(klass, &Arena_type, arena);
+  Arena* rb_arena = ALLOC(Arena);
+  upb_Arena* arena = upb_Arena_Init(NULL, 0, &ruby_upb_alloc);
+  if (!arena) {
+    xfree(rb_arena);
+    Arena_raise_oom();
+  }
+  rb_arena->arena = arena;
+  rb_arena->pinned_objs = Qnil;
+  return TypedData_Wrap_Struct(klass, &Arena_type, rb_arena);
 }
 
 upb_Arena* Arena_get(VALUE _arena) {
@@ -317,13 +353,33 @@ VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj) {
   }
 }
 
+static VALUE Google_Protobuf_Internal_allocation_count_is_available(
+    VALUE self) {
+  return upb_AllocationCount_IsAvailable() ? Qtrue : Qfalse;
+}
+
+static VALUE Google_Protobuf_Internal_allocation_count_get(VALUE self) {
+  return ULL2NUM(upb_AllocationCount_Get());
+}
+
+static VALUE Google_Protobuf_Internal_allocation_count_reset(VALUE self) {
+  upb_AllocationCount_Reset();
+  return Qnil;
+}
+
+static VALUE Google_Protobuf_Internal_allocation_count_fail_on(VALUE self,
+                                                               VALUE n) {
+  upb_AllocationCount_FailOn(NUM2ULL(n));
+  return Qnil;
+}
+
 // -----------------------------------------------------------------------------
 // Initialization/entry point.
 // -----------------------------------------------------------------------------
 
 // This must be named "Init_protobuf_c" because the Ruby module is named
 // "protobuf_c" -- the VM looks for this symbol in our .so.
-__attribute__((visibility("default"))) void Init_protobuf_c() {
+RUBY_FUNC_EXPORTED void Init_protobuf_c() {
   VALUE google = rb_define_module("Google");
   VALUE protobuf = rb_define_module_under(google, "Protobuf");
 
@@ -343,6 +399,19 @@ __attribute__((visibility("default"))) void Init_protobuf_c() {
                              Google_Protobuf_discard_unknown, 1);
   rb_define_singleton_method(protobuf, "deep_copy", Google_Protobuf_deep_copy,
                              1);
+
+  VALUE internal = rb_const_get(protobuf, rb_intern("Internal"));
+  rb_define_singleton_method(
+      internal, "allocation_count_is_available",
+      Google_Protobuf_Internal_allocation_count_is_available, 0);
+  rb_define_singleton_method(internal, "allocation_count_get",
+                             Google_Protobuf_Internal_allocation_count_get, 0);
+  rb_define_singleton_method(internal, "allocation_count_reset",
+                             Google_Protobuf_Internal_allocation_count_reset,
+                             0);
+  rb_define_singleton_method(internal, "allocation_count_fail_on",
+                             Google_Protobuf_Internal_allocation_count_fail_on,
+                             1);
 }
 
 // -----------------------------------------------------------------------------

data/ext/google/protobuf_c/protobuf.h

@@ -39,6 +39,7 @@ const upb_FieldDef* map_field_value(const upb_FieldDef* field);
 
 VALUE Arena_new();
 upb_Arena* Arena_get(VALUE arena);
+void Arena_raise_oom(void);
 
 // Fuses this arena to another, throwing a Ruby exception if this is not
 // possible.