google-protobuf 3.19.4 → 3.23.3

data/ext/google/protobuf_c/defs.h

@@ -40,9 +40,9 @@
 // TypeInfo
 // -----------------------------------------------------------------------------
 
-// This bundles a upb_fieldtype_t and msgdef/enumdef when appropriate. This is
+// This bundles a upb_CType and msgdef/enumdef when appropriate. This is
 // convenient for functions that need type information but cannot necessarily
-// assume a upb_fielddef will be available.
+// assume a upb_FieldDef will be available.
 //
 // For example, Google::Protobuf::Map and Google::Protobuf::RepeatedField can
 // be constructed with type information alone:
@@ -51,21 +51,21 @@
 //   Google::Protobuf::RepeatedField.new(:message, FooMessage)
 
 typedef struct {
-  upb_fieldtype_t type;
+  upb_CType type;
   union {
-    const upb_msgdef* msgdef;      // When type == UPB_TYPE_MESSAGE
-    const upb_enumdef* enumdef;    // When type == UPB_TYPE_ENUM
+    const upb_MessageDef* msgdef;  // When type == kUpb_CType_Message
+    const upb_EnumDef* enumdef;    // When type == kUpb_CType_Enum
   } def;
 } TypeInfo;
 
-static inline TypeInfo TypeInfo_get(const upb_fielddef *f) {
-  TypeInfo ret = {upb_fielddef_type(f), {NULL}};
+static inline TypeInfo TypeInfo_get(const upb_FieldDef* f) {
+  TypeInfo ret = {upb_FieldDef_CType(f), {NULL}};
   switch (ret.type) {
-    case UPB_TYPE_MESSAGE:
-      ret.def.msgdef = upb_fielddef_msgsubdef(f);
+    case kUpb_CType_Message:
+      ret.def.msgdef = upb_FieldDef_MessageSubDef(f);
       break;
-    case UPB_TYPE_ENUM:
-      ret.def.enumdef = upb_fielddef_enumsubdef(f);
+    case kUpb_CType_Enum:
+      ret.def.enumdef = upb_FieldDef_EnumSubDef(f);
       break;
     default:
       break;
@@ -76,9 +76,9 @@ static inline TypeInfo TypeInfo_get(const upb_fielddef *f) {
 TypeInfo TypeInfo_FromClass(int argc, VALUE* argv, int skip_arg,
                             VALUE* type_class, VALUE* init_arg);
 
-static inline TypeInfo TypeInfo_from_type(upb_fieldtype_t type) {
+static inline TypeInfo TypeInfo_from_type(upb_CType type) {
   TypeInfo ret = {type};
-  assert(type != UPB_TYPE_MESSAGE && type != UPB_TYPE_ENUM);
+  assert(type != kUpb_CType_Message && type != kUpb_CType_Enum);
   return ret;
 }
 
@@ -86,17 +86,17 @@ static inline TypeInfo TypeInfo_from_type(upb_fieldtype_t type) {
 // Other utilities
 // -----------------------------------------------------------------------------
 
-VALUE Descriptor_DefToClass(const upb_msgdef *m);
+VALUE Descriptor_DefToClass(const upb_MessageDef* m);
 
 // Returns the underlying msgdef, enumdef, or symtab (respectively) for the
 // given Descriptor, EnumDescriptor, or DescriptorPool Ruby object.
-const upb_enumdef *EnumDescriptor_GetEnumDef(VALUE enum_desc_rb);
-const upb_symtab *DescriptorPool_GetSymtab(VALUE desc_pool_rb);
-const upb_msgdef *Descriptor_GetMsgDef(VALUE desc_rb);
+const upb_EnumDef* EnumDescriptor_GetEnumDef(VALUE enum_desc_rb);
+const upb_DefPool* DescriptorPool_GetSymtab(VALUE desc_pool_rb);
+const upb_MessageDef* Descriptor_GetMsgDef(VALUE desc_rb);
 
 // Returns a upb field type for the given Ruby symbol
-// (eg. :float => UPB_TYPE_FLOAT).
-upb_fieldtype_t ruby_to_fieldtype(VALUE type);
+// (eg. :float => kUpb_CType_Float).
+upb_CType ruby_to_fieldtype(VALUE type);
 
 // The singleton generated pool (a DescriptorPool object).
 extern VALUE generated_pool;

data/ext/google/protobuf_c/extconf.rb

@@ -2,19 +2,26 @@
 
 require 'mkmf'
 
-if RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/
+ext_name = "google/protobuf_c"
+
+dir_config(ext_name)
+
+if RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/ || RUBY_PLATFORM =~ /freebsd/
   $CFLAGS += " -std=gnu99 -O3 -DNDEBUG -fvisibility=hidden -Wall -Wsign-compare -Wno-declaration-after-statement"
 else
   $CFLAGS += " -std=gnu99 -O3 -DNDEBUG"
 end
 
-
 if RUBY_PLATFORM =~ /linux/
   # Instruct the linker to point memcpy calls at our __wrap_memcpy wrapper.
   $LDFLAGS += " -Wl,-wrap,memcpy"
 end
 
-$objs = ["protobuf.o", "convert.o", "defs.o", "message.o",
-         "repeated_field.o", "map.o", "ruby-upb.o", "wrap_memcpy.o"]
+$VPATH << "$(srcdir)/third_party/utf8_range"
+$INCFLAGS += " -I$(srcdir)/third_party/utf8_range"
+
+$srcs = ["protobuf.c", "convert.c", "defs.c", "message.c",
+         "repeated_field.c", "map.c", "ruby-upb.c", "wrap_memcpy.c",
+         "naive.c", "range2-neon.c", "range2-sse.c"]
 
-create_makefile("google/protobuf_c")
+create_makefile(ext_name)

data/ext/google/protobuf_c/map.c

@@ -34,7 +34,7 @@
 #include "protobuf.h"
 
 // -----------------------------------------------------------------------------
-// Basic map operations on top of upb_map.
+// Basic map operations on top of upb_Map.
 //
 // Note that we roll our own `Map` container here because, as for
 // `RepeatedField`, we want a strongly-typed container. This is so that any user
@@ -48,8 +48,8 @@
 // -----------------------------------------------------------------------------
 
 typedef struct {
-  const upb_map *map;  // Can convert to mutable when non-frozen.
-  upb_fieldtype_t key_type;
+  const upb_Map* map;  // Can convert to mutable when non-frozen.
+  upb_CType key_type;
   TypeInfo value_type_info;
   VALUE value_type_class;
   VALUE arena;
@@ -62,9 +62,9 @@ static void Map_mark(void* _self) {
 }
 
 const rb_data_type_t Map_type = {
-  "Google::Protobuf::Map",
-  { Map_mark, RUBY_DEFAULT_FREE, NULL },
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    "Google::Protobuf::Map",
+    {Map_mark, RUBY_DEFAULT_FREE, NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 VALUE cMap;
@@ -84,8 +84,8 @@ static VALUE Map_alloc(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Map_type, self);
 }
 
-VALUE Map_GetRubyWrapper(upb_map* map, upb_fieldtype_t key_type,
-                         TypeInfo value_type, VALUE arena) {
+VALUE Map_GetRubyWrapper(upb_Map* map, upb_CType key_type, TypeInfo value_type,
+                         VALUE arena) {
   PBRUBY_ASSERT(map);
 
   VALUE val = ObjectCache_Get(map);
@@ -99,8 +99,8 @@ VALUE Map_GetRubyWrapper(upb_map* map, upb_fieldtype_t key_type,
     self->arena = arena;
     self->key_type = key_type;
     self->value_type_info = value_type;
-    if (self->value_type_info.type == UPB_TYPE_MESSAGE) {
-      const upb_msgdef *val_m = self->value_type_info.def.msgdef;
+    if (self->value_type_info.type == kUpb_CType_Message) {
+      const upb_MessageDef* val_m = self->value_type_info.def.msgdef;
       self->value_type_class = Descriptor_DefToClass(val_m);
     }
   }
@@ -108,9 +108,9 @@ VALUE Map_GetRubyWrapper(upb_map* map, upb_fieldtype_t key_type,
   return val;
 }
 
-static VALUE Map_new_this_type(Map *from) {
+static VALUE Map_new_this_type(Map* from) {
   VALUE arena_rb = Arena_new();
-  upb_map* map = upb_map_new(Arena_get(arena_rb), from->key_type,
+  upb_Map* map = upb_Map_New(Arena_get(arena_rb), from->key_type,
                              from->value_type_info.type);
   VALUE ret =
       Map_GetRubyWrapper(map, from->key_type, from->value_type_info, arena_rb);
@@ -125,22 +125,21 @@ static TypeInfo Map_keyinfo(Map* self) {
   return ret;
 }
 
-static upb_map *Map_GetMutable(VALUE _self) {
+static upb_Map* Map_GetMutable(VALUE _self) {
   rb_check_frozen(_self);
-  return (upb_map*)ruby_to_Map(_self)->map;
+  return (upb_Map*)ruby_to_Map(_self)->map;
 }
 
-VALUE Map_CreateHash(const upb_map* map, upb_fieldtype_t key_type,
+VALUE Map_CreateHash(const upb_Map* map, upb_CType key_type,
                      TypeInfo val_info) {
   VALUE hash = rb_hash_new();
-  size_t iter = UPB_MAP_BEGIN;
   TypeInfo key_info = TypeInfo_from_type(key_type);
 
   if (!map) return hash;
 
-  while (upb_mapiter_next(map, &iter)) {
-    upb_msgval key = upb_mapiter_key(map, iter);
-    upb_msgval val = upb_mapiter_value(map, iter);
+  size_t iter = kUpb_Map_Begin;
+  upb_MessageValue key, val;
+  while (upb_Map_Next(map, &key, &val, &iter)) {
     VALUE key_val = Convert_UpbToRuby(key, key_info, Qnil);
     VALUE val_val = Scalar_CreateHash(val, val_info);
     rb_hash_aset(hash, key_val, val_val);
@@ -152,25 +151,25 @@ VALUE Map_CreateHash(const upb_map* map, upb_fieldtype_t key_type,
 VALUE Map_deep_copy(VALUE obj) {
   Map* self = ruby_to_Map(obj);
   VALUE new_arena_rb = Arena_new();
-  upb_arena *arena = Arena_get(new_arena_rb);
-  upb_map* new_map =
-      upb_map_new(arena, self->key_type, self->value_type_info.type);
-  size_t iter = UPB_MAP_BEGIN;
-  while (upb_mapiter_next(self->map, &iter)) {
-    upb_msgval key = upb_mapiter_key(self->map, iter);
-    upb_msgval val = upb_mapiter_value(self->map, iter);
-    upb_msgval val_copy = Msgval_DeepCopy(val, self->value_type_info, arena);
-    upb_map_set(new_map, key, val_copy, arena);
+  upb_Arena* arena = Arena_get(new_arena_rb);
+  upb_Map* new_map =
+      upb_Map_New(arena, self->key_type, self->value_type_info.type);
+  size_t iter = kUpb_Map_Begin;
+  upb_MessageValue key, val;
+  while (upb_Map_Next(self->map, &key, &val, &iter)) {
+    upb_MessageValue val_copy =
+        Msgval_DeepCopy(val, self->value_type_info, arena);
+    upb_Map_Set(new_map, key, val_copy, arena);
   }
 
   return Map_GetRubyWrapper(new_map, self->key_type, self->value_type_info,
                             new_arena_rb);
 }
 
-const upb_map* Map_GetUpbMap(VALUE val, const upb_fielddef* field,
-                             upb_arena* arena) {
-  const upb_fielddef* key_field = map_field_key(field);
-  const upb_fielddef* value_field = map_field_value(field);
+const upb_Map* Map_GetUpbMap(VALUE val, const upb_FieldDef* field,
+                             upb_Arena* arena) {
+  const upb_FieldDef* key_field = map_field_key(field);
+  const upb_FieldDef* value_field = map_field_value(field);
   TypeInfo value_type_info = TypeInfo_get(value_field);
   Map* self;
 
@@ -180,7 +179,7 @@ const upb_map* Map_GetUpbMap(VALUE val, const upb_fielddef* field,
   }
 
   self = ruby_to_Map(val);
-  if (self->key_type != upb_fielddef_type(key_field)) {
+  if (self->key_type != upb_FieldDef_CType(key_field)) {
     rb_raise(cTypeError, "Map key type does not match field's key type");
   }
   if (self->value_type_info.type != value_type_info.type) {
@@ -194,16 +193,15 @@ const upb_map* Map_GetUpbMap(VALUE val, const upb_fielddef* field,
   return self->map;
 }
 
-void Map_Inspect(StringBuilder* b, const upb_map* map, upb_fieldtype_t key_type,
+void Map_Inspect(StringBuilder* b, const upb_Map* map, upb_CType key_type,
                  TypeInfo val_type) {
   bool first = true;
   TypeInfo key_type_info = {key_type};
   StringBuilder_Printf(b, "{");
   if (map) {
-    size_t iter = UPB_MAP_BEGIN;
-    while (upb_mapiter_next(map, &iter)) {
-      upb_msgval key = upb_mapiter_key(map, iter);
-      upb_msgval val = upb_mapiter_value(map, iter);
+    size_t iter = kUpb_Map_Begin;
+    upb_MessageValue key, val;
+    while (upb_Map_Next(map, &key, &val, &iter)) {
       if (first) {
         first = false;
       } else {
@@ -219,10 +217,12 @@ void Map_Inspect(StringBuilder* b, const upb_map* map, upb_fieldtype_t key_type,
 
 static int merge_into_self_callback(VALUE key, VALUE val, VALUE _self) {
   Map* self = ruby_to_Map(_self);
-  upb_arena *arena = Arena_get(self->arena);
-  upb_msgval key_val = Convert_RubyToUpb(key, "", Map_keyinfo(self), arena);
-  upb_msgval val_val = Convert_RubyToUpb(val, "", self->value_type_info, arena);
-  upb_map_set(Map_GetMutable(_self), key_val, val_val, arena);
+  upb_Arena* arena = Arena_get(self->arena);
+  upb_MessageValue key_val =
+      Convert_RubyToUpb(key, "", Map_keyinfo(self), arena);
+  upb_MessageValue val_val =
+      Convert_RubyToUpb(val, "", self->value_type_info, arena);
+  upb_Map_Set(Map_GetMutable(_self), key_val, val_val, arena);
   return ST_CONTINUE;
 }
 
@@ -234,9 +234,8 @@ static VALUE Map_merge_into_self(VALUE _self, VALUE hashmap) {
              RTYPEDDATA_TYPE(hashmap) == &Map_type) {
     Map* self = ruby_to_Map(_self);
     Map* other = ruby_to_Map(hashmap);
-    upb_arena *arena = Arena_get(self->arena);
-    upb_msg *self_msg = Map_GetMutable(_self);
-    size_t iter = UPB_MAP_BEGIN;
+    upb_Arena* arena = Arena_get(self->arena);
+    upb_Message* self_msg = Map_GetMutable(_self);
 
     Arena_fuse(other->arena, arena);
 
@@ -246,10 +245,10 @@ static VALUE Map_merge_into_self(VALUE _self, VALUE hashmap) {
       rb_raise(rb_eArgError, "Attempt to merge Map with mismatching types");
     }
 
-    while (upb_mapiter_next(other->map, &iter)) {
-      upb_msgval key = upb_mapiter_key(other->map, iter);
-      upb_msgval val = upb_mapiter_value(other->map, iter);
-      upb_map_set(self_msg, key, val, arena);
+    size_t iter = kUpb_Map_Begin;
+    upb_MessageValue key, val;
+    while (upb_Map_Next(other->map, &key, &val, &iter)) {
+      upb_Map_Set(self_msg, key, val, arena);
     }
   } else {
     rb_raise(rb_eArgError, "Unknown type merging into Map");
@@ -305,20 +304,20 @@ static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
 
   // Check that the key type is an allowed type.
   switch (self->key_type) {
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_UINT64:
-    case UPB_TYPE_BOOL:
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
+    case kUpb_CType_Int32:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_UInt64:
+    case kUpb_CType_Bool:
+    case kUpb_CType_String:
+    case kUpb_CType_Bytes:
       // These are OK.
       break;
     default:
       rb_raise(rb_eArgError, "Invalid key type for map.");
   }
 
-  self->map = upb_map_new(Arena_get(self->arena), self->key_type,
+  self->map = upb_Map_New(Arena_get(self->arena), self->key_type,
                           self->value_type_info.type);
   ObjectCache_Add(self->map, _self);
 
@@ -339,11 +338,10 @@ static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
  */
 static VALUE Map_each(VALUE _self) {
   Map* self = ruby_to_Map(_self);
-  size_t iter = UPB_MAP_BEGIN;
+  size_t iter = kUpb_Map_Begin;
+  upb_MessageValue key, val;
 
-  while (upb_mapiter_next(self->map, &iter)) {
-    upb_msgval key = upb_mapiter_key(self->map, iter);
-    upb_msgval val = upb_mapiter_value(self->map, iter);
+  while (upb_Map_Next(self->map, &key, &val, &iter)) {
     VALUE key_val = Convert_UpbToRuby(key, Map_keyinfo(self), self->arena);
     VALUE val_val = Convert_UpbToRuby(val, self->value_type_info, self->arena);
     rb_yield_values(2, key_val, val_val);
@@ -360,11 +358,11 @@ static VALUE Map_each(VALUE _self) {
  */
 static VALUE Map_keys(VALUE _self) {
   Map* self = ruby_to_Map(_self);
-  size_t iter = UPB_MAP_BEGIN;
+  size_t iter = kUpb_Map_Begin;
   VALUE ret = rb_ary_new();
+  upb_MessageValue key, val;
 
-  while (upb_mapiter_next(self->map, &iter)) {
-    upb_msgval key = upb_mapiter_key(self->map, iter);
+  while (upb_Map_Next(self->map, &key, &val, &iter)) {
     VALUE key_val = Convert_UpbToRuby(key, Map_keyinfo(self), self->arena);
     rb_ary_push(ret, key_val);
   }
@@ -380,11 +378,11 @@ static VALUE Map_keys(VALUE _self) {
  */
 static VALUE Map_values(VALUE _self) {
   Map* self = ruby_to_Map(_self);
-  size_t iter = UPB_MAP_BEGIN;
+  size_t iter = kUpb_Map_Begin;
   VALUE ret = rb_ary_new();
+  upb_MessageValue key, val;
 
-  while (upb_mapiter_next(self->map, &iter)) {
-    upb_msgval val = upb_mapiter_value(self->map, iter);
+  while (upb_Map_Next(self->map, &key, &val, &iter)) {
     VALUE val_val = Convert_UpbToRuby(val, self->value_type_info, self->arena);
     rb_ary_push(ret, val_val);
   }
@@ -401,10 +399,11 @@ static VALUE Map_values(VALUE _self) {
  */
 static VALUE Map_index(VALUE _self, VALUE key) {
   Map* self = ruby_to_Map(_self);
-  upb_msgval key_upb = Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
-  upb_msgval val;
+  upb_MessageValue key_upb =
+      Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
+  upb_MessageValue val;
 
-  if (upb_map_get(self->map, key_upb, &val)) {
+  if (upb_Map_Get(self->map, key_upb, &val)) {
     return Convert_UpbToRuby(val, self->value_type_info, self->arena);
   } else {
     return Qnil;
@@ -421,11 +420,13 @@ static VALUE Map_index(VALUE _self, VALUE key) {
  */
 static VALUE Map_index_set(VALUE _self, VALUE key, VALUE val) {
   Map* self = ruby_to_Map(_self);
-  upb_arena *arena = Arena_get(self->arena);
-  upb_msgval key_upb = Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
-  upb_msgval val_upb = Convert_RubyToUpb(val, "", self->value_type_info, arena);
+  upb_Arena* arena = Arena_get(self->arena);
+  upb_MessageValue key_upb =
+      Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
+  upb_MessageValue val_upb =
+      Convert_RubyToUpb(val, "", self->value_type_info, arena);
 
-  upb_map_set(Map_GetMutable(_self), key_upb, val_upb, arena);
+  upb_Map_Set(Map_GetMutable(_self), key_upb, val_upb, arena);
 
   return val;
 }
@@ -439,9 +440,10 @@ static VALUE Map_index_set(VALUE _self, VALUE key, VALUE val) {
  */
 static VALUE Map_has_key(VALUE _self, VALUE key) {
   Map* self = ruby_to_Map(_self);
-  upb_msgval key_upb = Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
+  upb_MessageValue key_upb =
+      Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
 
-  if (upb_map_get(self->map, key_upb, NULL)) {
+  if (upb_Map_Get(self->map, key_upb, NULL)) {
     return Qtrue;
   } else {
     return Qfalse;
@@ -457,23 +459,17 @@ static VALUE Map_has_key(VALUE _self, VALUE key) {
  */
 static VALUE Map_delete(VALUE _self, VALUE key) {
   Map* self = ruby_to_Map(_self);
-  upb_msgval key_upb = Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
-  upb_msgval val_upb;
-  VALUE ret;
-
   rb_check_frozen(_self);
 
-  // TODO(haberman): make upb_map_delete() also capable of returning the deleted
-  // value.
-  if (upb_map_get(self->map, key_upb, &val_upb)) {
-    ret = Convert_UpbToRuby(val_upb, self->value_type_info, self->arena);
+  upb_MessageValue key_upb =
+      Convert_RubyToUpb(key, "", Map_keyinfo(self), NULL);
+  upb_MessageValue val_upb;
+
+  if (upb_Map_Delete(self->map, key_upb, &val_upb)) {
+    return Convert_UpbToRuby(val_upb, self->value_type_info, self->arena);
   } else {
-    ret = Qnil;
+    return Qnil;
   }
-
-  upb_map_delete(Map_GetMutable(_self), key_upb);
-
-  return ret;
 }
 
 /*
@@ -483,7 +479,7 @@ static VALUE Map_delete(VALUE _self, VALUE key) {
  * Removes all entries from the map.
  */
 static VALUE Map_clear(VALUE _self) {
-  upb_map_clear(Map_GetMutable(_self));
+  upb_Map_Clear(Map_GetMutable(_self));
   return Qnil;
 }
 
@@ -495,7 +491,7 @@ static VALUE Map_clear(VALUE _self) {
  */
 static VALUE Map_length(VALUE _self) {
   Map* self = ruby_to_Map(_self);
-  return ULL2NUM(upb_map_size(self->map));
+  return ULL2NUM(upb_Map_Size(self->map));
 }
 
 /*
@@ -509,16 +505,15 @@ static VALUE Map_dup(VALUE _self) {
   Map* self = ruby_to_Map(_self);
   VALUE new_map_rb = Map_new_this_type(self);
   Map* new_self = ruby_to_Map(new_map_rb);
-  size_t iter = UPB_MAP_BEGIN;
-  upb_arena *arena = Arena_get(new_self->arena);
-  upb_map *new_map = Map_GetMutable(new_map_rb);
+  size_t iter = kUpb_Map_Begin;
+  upb_Arena* arena = Arena_get(new_self->arena);
+  upb_Map* new_map = Map_GetMutable(new_map_rb);
 
   Arena_fuse(self->arena, arena);
 
-  while (upb_mapiter_next(self->map, &iter)) {
-    upb_msgval key = upb_mapiter_key(self->map, iter);
-    upb_msgval val = upb_mapiter_value(self->map, iter);
-    upb_map_set(new_map, key, val, arena);
+  upb_MessageValue key, val;
+  while (upb_Map_Next(self->map, &key, &val, &iter)) {
+    upb_Map_Set(new_map, key, val, arena);
   }
 
   return new_map_rb;
@@ -559,18 +554,17 @@ VALUE Map_eq(VALUE _self, VALUE _other) {
       self->value_type_class != other->value_type_class) {
     return Qfalse;
   }
-  if (upb_map_size(self->map) != upb_map_size(other->map)) {
+  if (upb_Map_Size(self->map) != upb_Map_Size(other->map)) {
     return Qfalse;
   }
 
   // For each member of self, check that an equal member exists at the same key
   // in other.
-  size_t iter = UPB_MAP_BEGIN;
-  while (upb_mapiter_next(self->map, &iter)) {
-    upb_msgval key = upb_mapiter_key(self->map, iter);
-    upb_msgval val = upb_mapiter_value(self->map, iter);
-    upb_msgval other_val;
-    if (!upb_map_get(other->map, key, &other_val)) {
+  size_t iter = kUpb_Map_Begin;
+  upb_MessageValue key, val;
+  while (upb_Map_Next(self->map, &key, &val, &iter)) {
+    upb_MessageValue other_val;
+    if (!upb_Map_Get(other->map, key, &other_val)) {
       // Not present in other map.
       return Qfalse;
     }
@@ -609,11 +603,10 @@ VALUE Map_hash(VALUE _self) {
   Map* self = ruby_to_Map(_self);
   uint64_t hash = 0;
 
-  size_t iter = UPB_MAP_BEGIN;
+  size_t iter = kUpb_Map_Begin;
   TypeInfo key_info = {self->key_type};
-  while (upb_mapiter_next(self->map, &iter)) {
-    upb_msgval key = upb_mapiter_key(self->map, iter);
-    upb_msgval val = upb_mapiter_value(self->map, iter);
+  upb_MessageValue key, val;
+  while (upb_Map_Next(self->map, &key, &val, &iter)) {
     hash = Msgval_GetHash(key, key_info, hash);
     hash = Msgval_GetHash(val, self->value_type_info, hash);
   }

data/ext/google/protobuf_c/map.h

@@ -38,22 +38,21 @@
 
 // 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_fieldtype_t key_type,
-                         TypeInfo value_type, VALUE arena);
+VALUE Map_GetRubyWrapper(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
+// 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
 // match, raises an exception.
-const upb_map *Map_GetUpbMap(VALUE val, const upb_fielddef *field,
-                             upb_arena *arena);
+const upb_Map *Map_GetUpbMap(VALUE val, const upb_FieldDef *field,
+                             upb_Arena *arena);
 
 // Implements #inspect for this map by appending its contents to |b|.
-void Map_Inspect(StringBuilder *b, const upb_map *map, upb_fieldtype_t key_type,
+void Map_Inspect(StringBuilder *b, const upb_Map *map, upb_CType key_type,
                  TypeInfo val_type);
 
 // Returns a new Hash object containing the contents of this Map.
-VALUE Map_CreateHash(const upb_map* map, upb_fieldtype_t key_type,
-                     TypeInfo val_info);
+VALUE Map_CreateHash(const upb_Map *map, upb_CType key_type, TypeInfo val_info);
 
 // Returns a deep copy of this Map object.
 VALUE Map_deep_copy(VALUE obj);