google-protobuf 3.19.1 → 4.30.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a7485f1fc8d0d8ed8af84137ec365bcdc391674987b4db9c1b48e3e9be60a4e
-  data.tar.gz: 4158ac5aa052a96975a26ef4c4c491920cb84ec0a1739c0aad02a73f4b6d7f56
+  metadata.gz: b5125cc8af8296e8ccc158044588e8aa997acb0a4dfc12b8f70207c4b6e0e312
+  data.tar.gz: 9aaaeb8e9c9b0ced47d7c14a5d3d2da37e43c6b12fd32177d87fa055b59426d0
 SHA512:
-  metadata.gz: 23820237278d42df4366dc0bbd8d21d1834a493a67e82832d7c36c9d60984ba4106be49cbbacfd9cb7ab0c6bed772333d1e10f0598d48788d1c419db06474f8f
-  data.tar.gz: '019518d126196c733375e1b4ed0f34a438c5953991a1cd34c8eff6b33c8dd714954babb570bd4e779eb6c2af26eb9dca29564653ea2162c76ab1ded2fa1279e9'
+  metadata.gz: cc4490fe009fdf955ac03163cde61170975faba127c6987819321d6c45ef9d20823f44d25b883881c5bb2faab630c01e8a0519a20466abc624d018a759a73b33
+  data.tar.gz: 7b2364e5c5a7056df7684eed5be81b03f4806a53e8f8f9e381f879b8c11e640e191ab72e1abbf7db56f1aae8e299d4f260b2138367f657911542ad87174f031a

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,148 +104,175 @@ 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;
+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) {
+      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;
 
   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: {
-      VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
-      if (CLASS_OF(value) == rb_cSymbol) {
+    case kUpb_CType_String:
+      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)));
-      }
-
-      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");
-        }
+      } else if (!rb_obj_is_kind_of(value, rb_cString)) {
+        rb_raise(cTypeError,
+                 "Invalid argument for string field '%s' (given %s).", name,
+                 rb_class2name(CLASS_OF(value)));
       }
 
+      value = Convert_CheckStringUtf8(value);
       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:
+          rb_raise(cTypeError, "Convert_RubyToUpb(): Unexpected type %d",
+                   (int)type_info.type);
       }
       break;
     default:
-      break;
+      rb_raise(cTypeError,
+                "Convert_RubyToUpb(): Unexpected type %d", (int)type_info.type);
   }
 
   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 +280,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 +306,30 @@ 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, "Msgval_IsEqual(): %s",
+             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, "Msgval_GetHash(): %s",
+             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_