google-protobuf 3.19.4 → 3.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b2d8d23ee73555093c96e12a9915ae2d827fa93916ec1c2f13b1410b213ae3b
-  data.tar.gz: 8b915c10d1817642f5d3427e88285b03df6251de4b35b40683fc57625c7ab600
+  metadata.gz: f07b3e363c6a69664f352f94158f1c150d11fc6947fd8aafe1d06decbed0a545
+  data.tar.gz: dd3bb39d53484b82469238a0fd009d2049d4c1ce5732b1c141e73a1f5b23c8bb
 SHA512:
-  metadata.gz: 55d7d59cf630737bfd96c705af5877ec7bdd08c4bca5da7f3d701cc7e0fac4f258cba73b14aee68eef5c1f9406f7228c27a2f0a75365720ee1744caa9e8a5e8e
-  data.tar.gz: a26bf9e6f8faeffe2b74901f7bd85b63b9afecab6426fde9fa2aa77ac1ca502faa3635bdd01b5289531fc3827065575ab5cc46356ef2ec57476a0621e416be63
+  metadata.gz: '028e14308853bce11c830bd55735df413954ac79a986e46375964907ca984f5f93bf4cf0ed8632c175b5fe9946724d270a999733778e735f568fa215018275f9'
+  data.tar.gz: 3f6832e092254e27ca64fdf11367cb3a4e4a0e8f34d6e824044a8e701bcea5e88e4b8aaeba81ea8b83ab5e5a834969c074ba034e056cdc26484822064c0403f6

data/ext/google/protobuf_c/Rakefile

@@ -0,0 +1,3 @@
+import '../../../lib/google/tasks/ffi.rake'
+
+task default: ['ffi-protobuf:default']

data/ext/google/protobuf_c/convert.c

@@ -1,37 +1,14 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
 
 // -----------------------------------------------------------------------------
 // Ruby <-> upb data conversion functions.
 //
-// This file Also contains a few other assorted algorithms on upb_msgval.
+// This file Also contains a few other assorted algorithms on upb_MessageValue.
 //
 // None of the algorithms in this file require any access to the internal
 // representation of Ruby or upb objects.
@@ -41,11 +18,12 @@
 
 #include "message.h"
 #include "protobuf.h"
+#include "shared_convert.h"
 
-static upb_strview Convert_StringData(VALUE str, upb_arena *arena) {
-  upb_strview ret;
+static upb_StringView Convert_StringData(VALUE str, upb_Arena* arena) {
+  upb_StringView ret;
   if (arena) {
-    char *ptr = upb_arena_malloc(arena, RSTRING_LEN(str));
+    char* ptr = upb_Arena_Malloc(arena, RSTRING_LEN(str));
     memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
     ret.data = ptr;
   } else {
@@ -57,13 +35,11 @@ static upb_strview Convert_StringData(VALUE str, upb_arena *arena) {
 }
 
 static bool is_ruby_num(VALUE value) {
-  return (TYPE(value) == T_FLOAT ||
-          TYPE(value) == T_FIXNUM ||
+  return (TYPE(value) == T_FLOAT || TYPE(value) == T_FIXNUM ||
           TYPE(value) == T_BIGNUM);
 }
 
-static void Convert_CheckInt(const char* name, upb_fieldtype_t type,
-                             VALUE val) {
+static void Convert_CheckInt(const char* name, upb_CType type, VALUE val) {
   if (!is_ruby_num(val)) {
     rb_raise(cTypeError,
              "Expected number type for integral field '%s' (given %s).", name,
@@ -82,7 +58,7 @@ static void Convert_CheckInt(const char* name, upb_fieldtype_t type,
                name, rb_class2name(CLASS_OF(val)));
     }
   }
-  if (type == UPB_TYPE_UINT32 || type == UPB_TYPE_UINT64) {
+  if (type == kUpb_CType_UInt32 || type == kUpb_CType_UInt64) {
     if (NUM2DBL(val) < 0) {
       rb_raise(
           rb_eRangeError,
@@ -93,26 +69,30 @@ static void Convert_CheckInt(const char* name, upb_fieldtype_t type,
 }
 
 static int32_t Convert_ToEnum(VALUE value, const char* name,
-                              const upb_enumdef* e) {
+                              const upb_EnumDef* e) {
   int32_t val;
 
   switch (TYPE(value)) {
     case T_FLOAT:
     case T_FIXNUM:
     case T_BIGNUM:
-      Convert_CheckInt(name, UPB_TYPE_INT32, value);
+      Convert_CheckInt(name, kUpb_CType_Int32, value);
       val = NUM2INT(value);
       break;
-    case T_STRING:
-      if (!upb_enumdef_ntoi(e, RSTRING_PTR(value), RSTRING_LEN(value), &val)) {
-        goto unknownval;
-      }
+    case T_STRING: {
+      const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNameWithSize(
+          e, RSTRING_PTR(value), RSTRING_LEN(value));
+      if (!ev) goto unknownval;
+      val = upb_EnumValueDef_Number(ev);
       break;
-    case T_SYMBOL:
-      if (!upb_enumdef_ntoiz(e, rb_id2name(SYM2ID(value)), &val)) {
-        goto unknownval;
-      }
+    }
+    case T_SYMBOL: {
+      const upb_EnumValueDef* ev =
+          upb_EnumDef_FindValueByName(e, rb_id2name(SYM2ID(value)));
+      if (!ev) goto unknownval;
+      val = upb_EnumValueDef_Number(ev);
       break;
+    }
     default:
       rb_raise(cTypeError,
                "Expected number or symbol type for enum field '%s'.", name);
@@ -124,47 +104,52 @@ unknownval:
   rb_raise(rb_eRangeError, "Unknown symbol value for enum field '%s'.", name);
 }
 
-upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
-                             upb_arena* arena) {
-  upb_msgval ret;
+upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
+                                   TypeInfo type_info, upb_Arena* arena) {
+  upb_MessageValue ret;
 
   switch (type_info.type) {
-    case UPB_TYPE_FLOAT:
+    case kUpb_CType_Float:
       if (!is_ruby_num(value)) {
-        rb_raise(cTypeError, "Expected number type for float field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+        rb_raise(cTypeError,
+                 "Expected number type for float field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
       ret.float_val = NUM2DBL(value);
       break;
-    case UPB_TYPE_DOUBLE:
+    case kUpb_CType_Double:
       if (!is_ruby_num(value)) {
-        rb_raise(cTypeError, "Expected number type for double field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+        rb_raise(cTypeError,
+                 "Expected number type for double field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
       ret.double_val = NUM2DBL(value);
       break;
-    case UPB_TYPE_BOOL: {
+    case kUpb_CType_Bool: {
       if (value == Qtrue) {
         ret.bool_val = 1;
       } else if (value == Qfalse) {
         ret.bool_val = 0;
       } else {
-        rb_raise(cTypeError, "Invalid argument for boolean field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+        rb_raise(cTypeError,
+                 "Invalid argument for boolean field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
       break;
     }
-    case UPB_TYPE_STRING: {
+    case kUpb_CType_String: {
       VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
-      if (CLASS_OF(value) == rb_cSymbol) {
+      if (rb_obj_class(value) == rb_cSymbol) {
         value = rb_funcall(value, rb_intern("to_s"), 0);
-      } else if (CLASS_OF(value) != rb_cString) {
-        rb_raise(cTypeError, "Invalid argument for string field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+      } else if (rb_obj_class(value) != rb_cString) {
+        rb_raise(cTypeError,
+                 "Invalid argument for string field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
 
       if (rb_obj_encoding(value) != utf8) {
-        // Note: this will not duplicate underlying string data unless necessary.
+        // 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) {
@@ -175,49 +160,51 @@ upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
       ret.str_val = Convert_StringData(value, arena);
       break;
     }
-    case UPB_TYPE_BYTES: {
+    case kUpb_CType_Bytes: {
       VALUE bytes = rb_enc_from_encoding(rb_ascii8bit_encoding());
-      if (CLASS_OF(value) != rb_cString) {
-        rb_raise(cTypeError, "Invalid argument for bytes field '%s' (given %s).",
-                 name, rb_class2name(CLASS_OF(value)));
+      if (rb_obj_class(value) != rb_cString) {
+        rb_raise(cTypeError,
+                 "Invalid argument for bytes field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
 
       if (rb_obj_encoding(value) != bytes) {
-        // Note: this will not duplicate underlying string data unless necessary.
-        // TODO(haberman): is this really necessary to get raw bytes?
+        // Note: this will not duplicate underlying string data unless
+        // necessary.
+        // TODO: is this really necessary to get raw bytes?
         value = rb_str_encode(value, bytes, 0, Qnil);
       }
 
       ret.str_val = Convert_StringData(value, arena);
       break;
     }
-    case UPB_TYPE_MESSAGE:
+    case kUpb_CType_Message:
       ret.msg_val =
           Message_GetUpbMessage(value, type_info.def.msgdef, name, arena);
       break;
-    case UPB_TYPE_ENUM:
+    case kUpb_CType_Enum:
       ret.int32_val = Convert_ToEnum(value, name, type_info.def.enumdef);
       break;
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_UINT64:
+    case kUpb_CType_Int32:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_UInt64:
       Convert_CheckInt(name, type_info.type, value);
       switch (type_info.type) {
-      case UPB_TYPE_INT32:
-        ret.int32_val = NUM2INT(value);
-        break;
-      case UPB_TYPE_INT64:
-        ret.int64_val = NUM2LL(value);
-        break;
-      case UPB_TYPE_UINT32:
-        ret.uint32_val = NUM2UINT(value);
-        break;
-      case UPB_TYPE_UINT64:
-        ret.uint64_val = NUM2ULL(value);
-        break;
-      default:
-        break;
+        case kUpb_CType_Int32:
+          ret.int32_val = NUM2INT(value);
+          break;
+        case kUpb_CType_Int64:
+          ret.int64_val = NUM2LL(value);
+          break;
+        case kUpb_CType_UInt32:
+          ret.uint32_val = NUM2UINT(value);
+          break;
+        case kUpb_CType_UInt64:
+          ret.uint64_val = NUM2ULL(value);
+          break;
+        default:
+          break;
       }
       break;
     default:
@@ -227,45 +214,46 @@ upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
   return ret;
 }
 
-VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena) {
+VALUE Convert_UpbToRuby(upb_MessageValue upb_val, TypeInfo type_info,
+                        VALUE arena) {
   switch (type_info.type) {
-    case UPB_TYPE_FLOAT:
+    case kUpb_CType_Float:
       return DBL2NUM(upb_val.float_val);
-    case UPB_TYPE_DOUBLE:
+    case kUpb_CType_Double:
       return DBL2NUM(upb_val.double_val);
-    case UPB_TYPE_BOOL:
+    case kUpb_CType_Bool:
       return upb_val.bool_val ? Qtrue : Qfalse;
-    case UPB_TYPE_INT32:
+    case kUpb_CType_Int32:
       return INT2NUM(upb_val.int32_val);
-    case UPB_TYPE_INT64:
+    case kUpb_CType_Int64:
       return LL2NUM(upb_val.int64_val);
-    case UPB_TYPE_UINT32:
+    case kUpb_CType_UInt32:
       return UINT2NUM(upb_val.uint32_val);
-    case UPB_TYPE_UINT64:
+    case kUpb_CType_UInt64:
       return ULL2NUM(upb_val.int64_val);
-    case UPB_TYPE_ENUM: {
-      const char* name =
-          upb_enumdef_iton(type_info.def.enumdef, upb_val.int32_val);
-      if (name) {
-        return ID2SYM(rb_intern(name));
+    case kUpb_CType_Enum: {
+      const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNumber(
+          type_info.def.enumdef, upb_val.int32_val);
+      if (ev) {
+        return ID2SYM(rb_intern(upb_EnumValueDef_Name(ev)));
       } else {
         return INT2NUM(upb_val.int32_val);
       }
     }
-    case UPB_TYPE_STRING: {
+    case kUpb_CType_String: {
       VALUE str_rb = rb_str_new(upb_val.str_val.data, upb_val.str_val.size);
       rb_enc_associate(str_rb, rb_utf8_encoding());
       rb_obj_freeze(str_rb);
       return str_rb;
     }
-    case UPB_TYPE_BYTES: {
+    case kUpb_CType_Bytes: {
       VALUE str_rb = rb_str_new(upb_val.str_val.data, upb_val.str_val.size);
       rb_enc_associate(str_rb, rb_ascii8bit_encoding());
       rb_obj_freeze(str_rb);
       return str_rb;
     }
-    case UPB_TYPE_MESSAGE:
-      return Message_GetRubyWrapper((upb_msg*)upb_val.msg_val,
+    case kUpb_CType_Message:
+      return Message_GetRubyWrapper((upb_Message*)upb_val.msg_val,
                                     type_info.def.msgdef, arena);
     default:
       rb_raise(rb_eRuntimeError, "Convert_UpbToRuby(): Unexpected type %d",
@@ -273,24 +261,24 @@ VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena) {
   }
 }
 
-upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
-                           upb_arena* arena) {
-  upb_msgval new_msgval;
+upb_MessageValue Msgval_DeepCopy(upb_MessageValue msgval, TypeInfo type_info,
+                                 upb_Arena* arena) {
+  upb_MessageValue new_msgval;
 
   switch (type_info.type) {
     default:
       memcpy(&new_msgval, &msgval, sizeof(msgval));
       break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES: {
+    case kUpb_CType_String:
+    case kUpb_CType_Bytes: {
       size_t n = msgval.str_val.size;
-      char *mem = upb_arena_malloc(arena, n);
+      char* mem = upb_Arena_Malloc(arena, n);
       new_msgval.str_val.data = mem;
       new_msgval.str_val.size = n;
       memcpy(mem, msgval.str_val.data, n);
       break;
     }
-    case UPB_TYPE_MESSAGE:
+    case kUpb_CType_Message:
       new_msgval.msg_val =
           Message_deep_copy(msgval.msg_val, type_info.def.msgdef, arena);
       break;
@@ -299,50 +287,28 @@ upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
   return new_msgval;
 }
 
-bool Msgval_IsEqual(upb_msgval val1, upb_msgval val2, TypeInfo type_info) {
-  switch (type_info.type) {
-    case UPB_TYPE_BOOL:
-      return memcmp(&val1, &val2, 1) == 0;
-    case UPB_TYPE_FLOAT:
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_ENUM:
-      return memcmp(&val1, &val2, 4) == 0;
-    case UPB_TYPE_DOUBLE:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT64:
-      return memcmp(&val1, &val2, 8) == 0;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-      return val1.str_val.size == val2.str_val.size &&
-             memcmp(val1.str_val.data, val2.str_val.data,
-                    val1.str_val.size) == 0;
-    case UPB_TYPE_MESSAGE:
-      return Message_Equal(val1.msg_val, val2.msg_val, type_info.def.msgdef);
-    default:
-      rb_raise(rb_eRuntimeError, "Internal error, unexpected type");
+bool Msgval_IsEqual(upb_MessageValue val1, upb_MessageValue val2,
+                    TypeInfo type_info) {
+  upb_Status status;
+  upb_Status_Clear(&status);
+  bool return_value = shared_Msgval_IsEqual(val1, val2, type_info.type,
+                                            type_info.def.msgdef, &status);
+  if (upb_Status_IsOk(&status)) {
+    return return_value;
+  } else {
+    rb_raise(rb_eRuntimeError, upb_Status_ErrorMessage(&status));
   }
 }
 
-uint64_t Msgval_GetHash(upb_msgval val, TypeInfo type_info, uint64_t seed) {
-  switch (type_info.type) {
-    case UPB_TYPE_BOOL:
-      return Wyhash(&val, 1, seed, kWyhashSalt);
-    case UPB_TYPE_FLOAT:
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_ENUM:
-      return Wyhash(&val, 4, seed, kWyhashSalt);
-    case UPB_TYPE_DOUBLE:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT64:
-      return Wyhash(&val, 8, seed, kWyhashSalt);
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-      return Wyhash(val.str_val.data, val.str_val.size, seed, kWyhashSalt);
-    case UPB_TYPE_MESSAGE:
-      return Message_Hash(val.msg_val, type_info.def.msgdef, seed);
-    default:
-      rb_raise(rb_eRuntimeError, "Internal error, unexpected type");
+uint64_t Msgval_GetHash(upb_MessageValue val, TypeInfo type_info,
+                        uint64_t seed) {
+  upb_Status status;
+  upb_Status_Clear(&status);
+  uint64_t return_value = shared_Msgval_GetHash(
+      val, type_info.type, type_info.def.msgdef, seed, &status);
+  if (upb_Status_IsOk(&status)) {
+    return return_value;
+  } else {
+    rb_raise(rb_eRuntimeError, upb_Status_ErrorMessage(&status));
   }
 }

data/ext/google/protobuf_c/convert.h

@@ -1,42 +1,17 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
 
 #ifndef RUBY_PROTOBUF_CONVERT_H_
 #define RUBY_PROTOBUF_CONVERT_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 
-// Converts |ruby_val| to a upb_msgval according to |type_info|.
+// Converts |ruby_val| to a upb_MessageValue according to |type_info|.
 //
 // The |arena| parameter indicates the lifetime of the container where this
 // value will be assigned. It is used as follows:
@@ -47,8 +22,8 @@
 // - If type is message and the Ruby value is a message instance, we will fuse
 //   the message's arena into |arena|, to ensure that this message outlives the
 //   container.
-upb_msgval Convert_RubyToUpb(VALUE ruby_val, const char *name,
-                             TypeInfo type_info, upb_arena *arena);
+upb_MessageValue Convert_RubyToUpb(VALUE ruby_val, const char *name,
+                                   TypeInfo type_info, upb_Arena *arena);
 
 // Converts |upb_val| to a Ruby VALUE according to |type_info|. This may involve
 // creating a Ruby wrapper object.
@@ -56,17 +31,20 @@ upb_msgval Convert_RubyToUpb(VALUE ruby_val, const char *name,
 // The |arena| parameter indicates the arena that owns the lifetime of
 // |upb_val|. Any Ruby wrapper object that is created will reference |arena|
 // and ensure it outlives the wrapper.
-VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena);
+VALUE Convert_UpbToRuby(upb_MessageValue upb_val, TypeInfo type_info,
+                        VALUE arena);
 
 // Creates a deep copy of |msgval| in |arena|.
-upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
-                           upb_arena *arena);
+upb_MessageValue Msgval_DeepCopy(upb_MessageValue msgval, TypeInfo type_info,
+                                 upb_Arena *arena);
 
 // Returns true if |val1| and |val2| are equal. Their type is given by
 // |type_info|.
-bool Msgval_IsEqual(upb_msgval val1, upb_msgval val2, TypeInfo type_info);
+bool Msgval_IsEqual(upb_MessageValue val1, upb_MessageValue val2,
+                    TypeInfo type_info);
 
-// Returns a hash value for the given upb_msgval.
-uint64_t Msgval_GetHash(upb_msgval val, TypeInfo type_info, uint64_t seed);
+// Returns a hash value for the given upb_MessageValue.
+uint64_t Msgval_GetHash(upb_MessageValue val, TypeInfo type_info,
+                        uint64_t seed);
 
 #endif  // RUBY_PROTOBUF_CONVERT_H_