google-protobuf 3.22.2 → 4.30.1

data/ext/google/protobuf_c/defs.c

@@ -1,36 +1,12 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2014 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
 
 #include <ctype.h>
 #include <errno.h>
-#include <ruby/version.h>
 
 #include "convert.h"
 #include "message.h"
@@ -46,6 +22,9 @@ static VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_EnumDef* def);
 static VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_FieldDef* def);
 static VALUE get_filedef_obj(VALUE descriptor_pool, const upb_FileDef* def);
 static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_OneofDef* def);
+static VALUE get_servicedef_obj(VALUE descriptor_pool,
+                                const upb_ServiceDef* def);
+static VALUE get_methoddef_obj(VALUE descriptor_pool, const upb_MethodDef* def);
 
 // A distinct object that is not accessible from Ruby.  We use this as a
 // constructor argument to enforce that certain objects cannot be created from
@@ -67,12 +46,14 @@ static VALUE rb_str_maybe_null(const char* s) {
   }
   return rb_str_new2(s);
 }
-
+static ID options_instancevar_interned;
 // -----------------------------------------------------------------------------
 // DescriptorPool.
 // -----------------------------------------------------------------------------
 
 typedef struct {
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE def_to_descriptor;  // Hash table of def* -> Ruby descriptor.
   upb_DefPool* symtab;
 } DescriptorPool;
@@ -97,7 +78,7 @@ static void DescriptorPool_free(void* _self) {
 static const rb_data_type_t DescriptorPool_type = {
     "Google::Protobuf::DescriptorPool",
     {DescriptorPool_mark, DescriptorPool_free, NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static DescriptorPool* ruby_to_DescriptorPool(VALUE val) {
@@ -125,11 +106,9 @@ static VALUE DescriptorPool_alloc(VALUE klass) {
   self->def_to_descriptor = Qnil;
   ret = TypedData_Wrap_Struct(klass, &DescriptorPool_type, self);
 
-  self->def_to_descriptor = rb_hash_new();
+  RB_OBJ_WRITE(ret, &self->def_to_descriptor, rb_hash_new());
   self->symtab = upb_DefPool_New();
-  ObjectCache_Add(self->symtab, ret);
-
-  return ret;
+  return ObjectCache_TryAdd(self->symtab, ret);
 }
 
 /*
@@ -167,25 +146,37 @@ VALUE DescriptorPool_add_serialized_file(VALUE _self,
  * call-seq:
  *     DescriptorPool.lookup(name) => descriptor
  *
- * Finds a Descriptor or EnumDescriptor by name and returns it, or nil if none
- * exists with the given name.
+ * Finds a Descriptor, EnumDescriptor, FieldDescriptor or ServiceDescriptor by
+ * name and returns it, or nil if none exists with the given name.
  */
 static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
   DescriptorPool* self = ruby_to_DescriptorPool(_self);
   const char* name_str = get_str(name);
   const upb_MessageDef* msgdef;
   const upb_EnumDef* enumdef;
+  const upb_FieldDef* fielddef;
+  const upb_ServiceDef* servicedef;
 
   msgdef = upb_DefPool_FindMessageByName(self->symtab, name_str);
   if (msgdef) {
     return get_msgdef_obj(_self, msgdef);
   }
 
+  fielddef = upb_DefPool_FindExtensionByName(self->symtab, name_str);
+  if (fielddef) {
+    return get_fielddef_obj(_self, fielddef);
+  }
+
   enumdef = upb_DefPool_FindEnumByName(self->symtab, name_str);
   if (enumdef) {
     return get_enumdef_obj(_self, enumdef);
   }
 
+  servicedef = upb_DefPool_FindServiceByName(self->symtab, name_str);
+  if (servicedef) {
+    return get_servicedef_obj(_self, servicedef);
+  }
+
   return Qnil;
 }
 
@@ -215,6 +206,7 @@ static void DescriptorPool_register(VALUE module) {
 
   rb_gc_register_address(&generated_pool);
   generated_pool = rb_class_new_instance(0, NULL, klass);
+  options_instancevar_interned = rb_intern("options");
 }
 
 // -----------------------------------------------------------------------------
@@ -223,6 +215,8 @@ static void DescriptorPool_register(VALUE module) {
 
 typedef struct {
   const upb_MessageDef* msgdef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE klass;
   VALUE descriptor_pool;
 } Descriptor;
@@ -238,7 +232,7 @@ static void Descriptor_mark(void* _self) {
 static const rb_data_type_t Descriptor_type = {
     "Google::Protobuf::Descriptor",
     {Descriptor_mark, RUBY_DEFAULT_FREE, NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static Descriptor* ruby_to_Descriptor(VALUE val) {
@@ -247,6 +241,48 @@ static Descriptor* ruby_to_Descriptor(VALUE val) {
   return ret;
 }
 
+// Decode and return a frozen instance of a Descriptor Option for the given pool
+static VALUE decode_options(VALUE self, const char* option_type, int size,
+                            const char* bytes, VALUE descriptor_pool) {
+  VALUE options_rb = rb_ivar_get(self, options_instancevar_interned);
+  if (options_rb != Qnil) {
+    return options_rb;
+  }
+
+  static const char* prefix = "google.protobuf.";
+  char fullname
+      [/*strlen(prefix)*/ 16 +
+       /*strln(longest option type supported e.g. "MessageOptions")*/ 14 +
+       /*null terminator*/ 1];
+
+  snprintf(fullname, sizeof(fullname), "%s%s", prefix, option_type);
+  const upb_MessageDef* msgdef = upb_DefPool_FindMessageByName(
+      ruby_to_DescriptorPool(descriptor_pool)->symtab, fullname);
+  if (!msgdef) {
+    rb_raise(rb_eRuntimeError, "Cannot find %s in DescriptorPool", option_type);
+  }
+
+  VALUE desc_rb = get_msgdef_obj(descriptor_pool, msgdef);
+  const Descriptor* desc = ruby_to_Descriptor(desc_rb);
+
+  options_rb = Message_decode_bytes(size, bytes, 0, desc->klass, false);
+
+  // Strip features from the options proto to keep it internal.
+  const upb_MessageDef* decoded_desc = NULL;
+  upb_Message* options = Message_GetMutable(options_rb, &decoded_desc);
+  PBRUBY_ASSERT(options != NULL);
+  PBRUBY_ASSERT(decoded_desc == msgdef);
+  const upb_FieldDef* field =
+      upb_MessageDef_FindFieldByName(decoded_desc, "features");
+  PBRUBY_ASSERT(field != NULL);
+  upb_Message_ClearFieldByDef(options, field);
+
+  Message_freeze(options_rb);
+
+  rb_ivar_set(self, options_instancevar_interned, options_rb);
+  return options_rb;
+}
+
 /*
  * call-seq:
  *     Descriptor.new => descriptor
@@ -280,7 +316,7 @@ static VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
              "Descriptor objects may not be created from Ruby.");
   }
 
-  self->descriptor_pool = descriptor_pool;
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
   self->msgdef = (const upb_MessageDef*)NUM2ULL(ptr);
 
   return Qnil;
@@ -390,11 +426,52 @@ static VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
 static VALUE Descriptor_msgclass(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
   if (self->klass == Qnil) {
-    self->klass = build_class_from_descriptor(_self);
+    RB_OBJ_WRITE(_self, &self->klass, build_class_from_descriptor(_self));
   }
   return self->klass;
 }
 
+/*
+ * call-seq:
+ *     Descriptor.options => options
+ *
+ * Returns the `MessageOptions` for this `Descriptor`.
+ */
+static VALUE Descriptor_options(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
+  const google_protobuf_MessageOptions* opts =
+      upb_MessageDef_Options(self->msgdef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized =
+      google_protobuf_MessageOptions_serialize(opts, arena, &size);
+  VALUE message_options = decode_options(_self, "MessageOptions", size,
+                                         serialized, self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return message_options;
+}
+
+/*
+ * call-seq:
+ *     Descriptor.to_proto => DescriptorProto
+ *
+ * Returns the `DescriptorProto` of this `Descriptor`.
+ */
+static VALUE Descriptor_to_proto(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_DescriptorProto* proto =
+      upb_MessageDef_ToProto(self->msgdef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_DescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::DescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void Descriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "Descriptor", rb_cObject);
   rb_define_alloc_func(klass, Descriptor_alloc);
@@ -406,6 +483,8 @@ static void Descriptor_register(VALUE module) {
   rb_define_method(klass, "msgclass", Descriptor_msgclass, 0);
   rb_define_method(klass, "name", Descriptor_name, 0);
   rb_define_method(klass, "file_descriptor", Descriptor_file_descriptor, 0);
+  rb_define_method(klass, "options", Descriptor_options, 0);
+  rb_define_method(klass, "to_proto", Descriptor_to_proto, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cDescriptor);
   cDescriptor = klass;
@@ -417,6 +496,8 @@ static void Descriptor_register(VALUE module) {
 
 typedef struct {
   const upb_FileDef* filedef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE descriptor_pool;  // Owns the upb_FileDef.
 } FileDescriptor;
 
@@ -430,7 +511,7 @@ static void FileDescriptor_mark(void* _self) {
 static const rb_data_type_t FileDescriptor_type = {
     "Google::Protobuf::FileDescriptor",
     {FileDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static FileDescriptor* ruby_to_FileDescriptor(VALUE val) {
@@ -451,7 +532,7 @@ static VALUE FileDescriptor_alloc(VALUE klass) {
  * call-seq:
  *     FileDescriptor.new => file
  *
- * Returns a new file descriptor. The syntax must be set before it's passed
+ * Returns a new file descriptor. May
  * to a builder.
  */
 static VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
@@ -463,7 +544,7 @@ static VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
              "Descriptor objects may not be created from Ruby.");
   }
 
-  self->descriptor_pool = descriptor_pool;
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
   self->filedef = (const upb_FileDef*)NUM2ULL(ptr);
 
   return Qnil;
@@ -483,24 +564,44 @@ static VALUE FileDescriptor_name(VALUE _self) {
 
 /*
  * call-seq:
- *     FileDescriptor.syntax => syntax
+ *     FileDescriptor.options => options
  *
- * Returns this file descriptors syntax.
+ * Returns the `FileOptions` for this `FileDescriptor`.
+ */
+static VALUE FileDescriptor_options(VALUE _self) {
+  FileDescriptor* self = ruby_to_FileDescriptor(_self);
+  const google_protobuf_FileOptions* opts = upb_FileDef_Options(self->filedef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized = google_protobuf_FileOptions_serialize(opts, arena, &size);
+  VALUE file_options = decode_options(_self, "FileOptions", size, serialized,
+                                      self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return file_options;
+}
+
+/*
+ * call-seq:
+ *     FileDescriptor.to_proto => FileDescriptorProto
  *
- * Valid syntax versions are:
- *     :proto2 or :proto3.
+ * Returns the `FileDescriptorProto` of this `FileDescriptor`.
  */
-static VALUE FileDescriptor_syntax(VALUE _self) {
+static VALUE FileDescriptor_to_proto(VALUE _self) {
   FileDescriptor* self = ruby_to_FileDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_FileDescriptorProto* file_proto =
+      upb_FileDef_ToProto(self->filedef, arena);
 
-  switch (upb_FileDef_Syntax(self->filedef)) {
-    case kUpb_Syntax_Proto3:
-      return ID2SYM(rb_intern("proto3"));
-    case kUpb_Syntax_Proto2:
-      return ID2SYM(rb_intern("proto2"));
-    default:
-      return Qnil;
-  }
+  size_t size;
+  const char* serialized =
+      google_protobuf_FileDescriptorProto_serialize(file_proto, arena, &size);
+
+  VALUE file_proto_class =
+      rb_path2class("Google::Protobuf::FileDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, file_proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
 }
 
 static void FileDescriptor_register(VALUE module) {
@@ -508,7 +609,8 @@ static void FileDescriptor_register(VALUE module) {
   rb_define_alloc_func(klass, FileDescriptor_alloc);
   rb_define_method(klass, "initialize", FileDescriptor_initialize, 3);
   rb_define_method(klass, "name", FileDescriptor_name, 0);
-  rb_define_method(klass, "syntax", FileDescriptor_syntax, 0);
+  rb_define_method(klass, "options", FileDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", FileDescriptor_to_proto, 0);
   rb_gc_register_address(&cFileDescriptor);
   cFileDescriptor = klass;
 }
@@ -519,6 +621,8 @@ static void FileDescriptor_register(VALUE module) {
 
 typedef struct {
   const upb_FieldDef* fielddef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE descriptor_pool;  // Owns the upb_FieldDef.
 } FieldDescriptor;
 
@@ -532,7 +636,7 @@ static void FieldDescriptor_mark(void* _self) {
 static const rb_data_type_t FieldDescriptor_type = {
     "Google::Protobuf::FieldDescriptor",
     {FieldDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static FieldDescriptor* ruby_to_FieldDescriptor(VALUE val) {
@@ -557,7 +661,7 @@ static VALUE FieldDescriptor_alloc(VALUE klass) {
 
 /*
  * call-seq:
- *    EnumDescriptor.new(c_only_cookie, pool, ptr) => EnumDescriptor
+ *    FieldDescriptor.new(c_only_cookie, pool, ptr) => FieldDescriptor
  *
  * Creates a descriptor wrapper object.  May only be called from C.
  */
@@ -570,7 +674,7 @@ static VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
              "Descriptor objects may not be created from Ruby.");
   }
 
-  self->descriptor_pool = descriptor_pool;
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
   self->fielddef = (const upb_FieldDef*)NUM2ULL(ptr);
 
   return Qnil;
@@ -595,7 +699,7 @@ upb_CType ruby_to_fieldtype(VALUE type) {
 
 #define CONVERT(upb, ruby)                \
   if (SYM2ID(type) == rb_intern(#ruby)) { \
-    return kUpb_CType_##upb;                \
+    return kUpb_CType_##upb;              \
   }
 
   CONVERT(Float, float);
@@ -618,7 +722,7 @@ upb_CType ruby_to_fieldtype(VALUE type) {
 
 static VALUE descriptortype_to_ruby(upb_FieldType type) {
   switch (type) {
-#define CONVERT(upb, ruby)        \
+#define CONVERT(upb, ruby)   \
   case kUpb_FieldType_##upb: \
     return ID2SYM(rb_intern(#ruby));
     CONVERT(Float, float);
@@ -668,7 +772,7 @@ static VALUE FieldDescriptor__type(VALUE _self) {
 static VALUE FieldDescriptor_default(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_FieldDef* f = self->fielddef;
-  upb_MessageValue default_val = {0};
+  upb_MessageValue default_val = upb_MessageValue_Zero();
   if (upb_FieldDef_IsSubMessage(f)) {
     return Qnil;
   } else if (!upb_FieldDef_IsRepeated(f)) {
@@ -677,6 +781,28 @@ static VALUE FieldDescriptor_default(VALUE _self) {
   return Convert_UpbToRuby(default_val, TypeInfo_get(self->fielddef), Qnil);
 }
 
+/*
+ * call-seq:
+ *     FieldDescriptor.has_presence? => bool
+ *
+ * Returns whether this field tracks presence.
+ */
+static VALUE FieldDescriptor_has_presence(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_HasPresence(self->fielddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *     FieldDescriptor.is_packed? => bool
+ *
+ * Returns whether this is a repeated field that uses packed encoding.
+ */
+static VALUE FieldDescriptor_is_packed(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_IsPacked(self->fielddef) ? Qtrue : Qfalse;
+}
+
 /*
  * call-seq:
  *     FieldDescriptor.json_name => json_name
@@ -703,7 +829,7 @@ static VALUE FieldDescriptor_label(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   switch (upb_FieldDef_Label(self->fielddef)) {
 #define CONVERT(upb, ruby) \
-  case kUpb_Label_##upb:    \
+  case kUpb_Label_##upb:   \
     return ID2SYM(rb_intern(#ruby));
 
     CONVERT(Optional, optional);
@@ -803,7 +929,7 @@ static VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
 static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_MessageDef* m;
-  const upb_MessageDef* msg = Message_Get(msg_rb, &m);
+  const upb_Message* msg = Message_Get(msg_rb, &m);
 
   if (m != upb_FieldDef_ContainingType(self->fielddef)) {
     rb_raise(cTypeError, "has method called on wrong message type");
@@ -823,7 +949,7 @@ static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
 static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_MessageDef* m;
-  upb_MessageDef* msg = Message_GetMutable(msg_rb, &m);
+  upb_Message* msg = Message_GetMutable(msg_rb, &m);
 
   if (m != upb_FieldDef_ContainingType(self->fielddef)) {
     rb_raise(cTypeError, "has method called on wrong message type");
@@ -844,7 +970,7 @@ static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
 static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_MessageDef* m;
-  upb_MessageDef* msg = Message_GetMutable(msg_rb, &m);
+  upb_Message* msg = Message_GetMutable(msg_rb, &m);
   upb_Arena* arena = Arena_get(Message_GetArena(msg_rb));
   upb_MessageValue msgval;
 
@@ -858,6 +984,46 @@ static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
   return Qnil;
 }
 
+/*
+ * call-seq:
+ *     FieldDescriptor.options => options
+ *
+ * Returns the `FieldOptions` for this `FieldDescriptor`.
+ */
+static VALUE FieldDescriptor_options(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  const google_protobuf_FieldOptions* opts =
+      upb_FieldDef_Options(self->fielddef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized = google_protobuf_FieldOptions_serialize(opts, arena, &size);
+  VALUE field_options = decode_options(_self, "FieldOptions", size, serialized,
+                                       self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return field_options;
+}
+
+/*
+ * call-seq:
+ *     FieldDescriptor.to_proto => FieldDescriptorProto
+ *
+ * Returns the `FieldDescriptorProto` of this `FieldDescriptor`.
+ */
+static VALUE FieldDescriptor_to_proto(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_FieldDescriptorProto* proto =
+      upb_FieldDef_ToProto(self->fielddef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_FieldDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::FieldDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void FieldDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "FieldDescriptor", rb_cObject);
   rb_define_alloc_func(klass, FieldDescriptor_alloc);
@@ -865,6 +1031,8 @@ static void FieldDescriptor_register(VALUE module) {
   rb_define_method(klass, "name", FieldDescriptor_name, 0);
   rb_define_method(klass, "type", FieldDescriptor__type, 0);
   rb_define_method(klass, "default", FieldDescriptor_default, 0);
+  rb_define_method(klass, "has_presence?", FieldDescriptor_has_presence, 0);
+  rb_define_method(klass, "is_packed?", FieldDescriptor_is_packed, 0);
   rb_define_method(klass, "json_name", FieldDescriptor_json_name, 0);
   rb_define_method(klass, "label", FieldDescriptor_label, 0);
   rb_define_method(klass, "number", FieldDescriptor_number, 0);
@@ -874,6 +1042,8 @@ static void FieldDescriptor_register(VALUE module) {
   rb_define_method(klass, "clear", FieldDescriptor_clear, 1);
   rb_define_method(klass, "get", FieldDescriptor_get, 1);
   rb_define_method(klass, "set", FieldDescriptor_set, 2);
+  rb_define_method(klass, "options", FieldDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", FieldDescriptor_to_proto, 0);
   rb_gc_register_address(&cFieldDescriptor);
   cFieldDescriptor = klass;
 }
@@ -884,6 +1054,8 @@ static void FieldDescriptor_register(VALUE module) {
 
 typedef struct {
   const upb_OneofDef* oneofdef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE descriptor_pool;  // Owns the upb_OneofDef.
 } OneofDescriptor;
 
@@ -897,7 +1069,7 @@ static void OneofDescriptor_mark(void* _self) {
 static const rb_data_type_t OneofDescriptor_type = {
     "Google::Protobuf::OneofDescriptor",
     {OneofDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static OneofDescriptor* ruby_to_OneofDescriptor(VALUE val) {
@@ -936,7 +1108,7 @@ static VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
              "Descriptor objects may not be created from Ruby.");
   }
 
-  self->descriptor_pool = descriptor_pool;
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
   self->oneofdef = (const upb_OneofDef*)NUM2ULL(ptr);
 
   return Qnil;
@@ -971,12 +1143,54 @@ static VALUE OneofDescriptor_each(VALUE _self) {
   return Qnil;
 }
 
+/*
+ * call-seq:
+ *     OneofDescriptor.options => options
+ *
+ * Returns the `OneofOptions` for this `OneofDescriptor`.
+ */
+static VALUE OneOfDescriptor_options(VALUE _self) {
+  OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
+  const google_protobuf_OneofOptions* opts =
+      upb_OneofDef_Options(self->oneofdef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized = google_protobuf_OneofOptions_serialize(opts, arena, &size);
+  VALUE oneof_options = decode_options(_self, "OneofOptions", size, serialized,
+                                       self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return oneof_options;
+}
+
+/*
+ * call-seq:
+ *     OneofDescriptor.to_proto => OneofDescriptorProto
+ *
+ * Returns the `OneofDescriptorProto` of this `OneofDescriptor`.
+ */
+static VALUE OneOfDescriptor_to_proto(VALUE _self) {
+  OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_OneofDescriptorProto* proto =
+      upb_OneofDef_ToProto(self->oneofdef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_OneofDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::OneofDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void OneofDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "OneofDescriptor", rb_cObject);
   rb_define_alloc_func(klass, OneofDescriptor_alloc);
   rb_define_method(klass, "initialize", OneofDescriptor_initialize, 3);
   rb_define_method(klass, "name", OneofDescriptor_name, 0);
   rb_define_method(klass, "each", OneofDescriptor_each, 0);
+  rb_define_method(klass, "options", OneOfDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", OneOfDescriptor_to_proto, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cOneofDescriptor);
   cOneofDescriptor = klass;
@@ -988,6 +1202,8 @@ static void OneofDescriptor_register(VALUE module) {
 
 typedef struct {
   const upb_EnumDef* enumdef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE module;           // begins as nil
   VALUE descriptor_pool;  // Owns the upb_EnumDef.
 } EnumDescriptor;
@@ -1003,7 +1219,7 @@ static void EnumDescriptor_mark(void* _self) {
 static const rb_data_type_t EnumDescriptor_type = {
     "Google::Protobuf::EnumDescriptor",
     {EnumDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static EnumDescriptor* ruby_to_EnumDescriptor(VALUE val) {
@@ -1042,7 +1258,7 @@ static VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
              "Descriptor objects may not be created from Ruby.");
   }
 
-  self->descriptor_pool = descriptor_pool;
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
   self->enumdef = (const upb_EnumDef*)NUM2ULL(ptr);
 
   return Qnil;
@@ -1060,6 +1276,17 @@ static VALUE EnumDescriptor_file_descriptor(VALUE _self) {
                          upb_EnumDef_File(self->enumdef));
 }
 
+/*
+ * call-seq:
+ *     EnumDescriptor.is_closed? => bool
+ *
+ * Returns whether this enum is open or closed.
+ */
+static VALUE EnumDescriptor_is_closed(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
+  return upb_EnumDef_IsClosed(self->enumdef) ? Qtrue : Qfalse;
+}
+
 /*
  * call-seq:
  *     EnumDescriptor.name => name
@@ -1081,7 +1308,7 @@ static VALUE EnumDescriptor_name(VALUE _self) {
 static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   const char* name_str = rb_id2name(SYM2ID(name));
-  const upb_EnumValueDef *ev =
+  const upb_EnumValueDef* ev =
       upb_EnumDef_FindValueByName(self->enumdef, name_str);
   if (ev) {
     return INT2NUM(upb_EnumValueDef_Number(ev));
@@ -1100,7 +1327,8 @@ static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
 static VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   int32_t val = NUM2INT(number);
-  const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNumber(self->enumdef, val);
+  const upb_EnumValueDef* ev =
+      upb_EnumDef_FindValueByNumber(self->enumdef, val);
   if (ev) {
     return ID2SYM(rb_intern(upb_EnumValueDef_Name(ev)));
   } else {
@@ -1138,11 +1366,52 @@ static VALUE EnumDescriptor_each(VALUE _self) {
 static VALUE EnumDescriptor_enummodule(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   if (self->module == Qnil) {
-    self->module = build_module_from_enumdesc(_self);
+    RB_OBJ_WRITE(_self, &self->module, build_module_from_enumdesc(_self));
   }
   return self->module;
 }
 
+/*
+ * call-seq:
+ *     EnumDescriptor.options => options
+ *
+ * Returns the `EnumOptions` for this `EnumDescriptor`.
+ */
+static VALUE EnumDescriptor_options(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
+  const google_protobuf_EnumOptions* opts = upb_EnumDef_Options(self->enumdef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized = google_protobuf_EnumOptions_serialize(opts, arena, &size);
+  VALUE enum_options = decode_options(_self, "EnumOptions", size, serialized,
+                                      self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return enum_options;
+}
+
+/*
+ * call-seq:
+ *     EnumDescriptor.to_proto => EnumDescriptorProto
+ *
+ * Returns the `EnumDescriptorProto` of this `EnumDescriptor`.
+ */
+static VALUE EnumDescriptor_to_proto(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_EnumDescriptorProto* proto =
+      upb_EnumDef_ToProto(self->enumdef, arena);
+
+  size_t size;
+  const char* serialized =
+      google_protobuf_EnumDescriptorProto_serialize(proto, arena, &size);
+
+  VALUE proto_class = rb_path2class("Google::Protobuf::EnumDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void EnumDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "EnumDescriptor", rb_cObject);
   rb_define_alloc_func(klass, EnumDescriptor_alloc);
@@ -1153,11 +1422,350 @@ static void EnumDescriptor_register(VALUE module) {
   rb_define_method(klass, "each", EnumDescriptor_each, 0);
   rb_define_method(klass, "enummodule", EnumDescriptor_enummodule, 0);
   rb_define_method(klass, "file_descriptor", EnumDescriptor_file_descriptor, 0);
+  rb_define_method(klass, "is_closed?", EnumDescriptor_is_closed, 0);
+  rb_define_method(klass, "options", EnumDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", EnumDescriptor_to_proto, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cEnumDescriptor);
   cEnumDescriptor = klass;
 }
 
+// -----------------------------------------------------------------------------
+// ServiceDescriptor
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  const upb_ServiceDef* servicedef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  VALUE module;           // begins as nil
+  VALUE descriptor_pool;  // Owns the upb_ServiceDef.
+} ServiceDescriptor;
+
+static VALUE cServiceDescriptor = Qnil;
+
+static void ServiceDescriptor_mark(void* _self) {
+  ServiceDescriptor* self = _self;
+  rb_gc_mark(self->module);
+  rb_gc_mark(self->descriptor_pool);
+}
+
+static const rb_data_type_t ServiceDescriptor_type = {
+    "Google::Protobuf::ServicDescriptor",
+    {ServiceDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static ServiceDescriptor* ruby_to_ServiceDescriptor(VALUE val) {
+  ServiceDescriptor* ret;
+  TypedData_Get_Struct(val, ServiceDescriptor, &ServiceDescriptor_type, ret);
+  return ret;
+}
+
+static VALUE ServiceDescriptor_alloc(VALUE klass) {
+  ServiceDescriptor* self = ALLOC(ServiceDescriptor);
+  VALUE ret = TypedData_Wrap_Struct(klass, &ServiceDescriptor_type, self);
+  self->servicedef = NULL;
+  self->module = Qnil;
+  self->descriptor_pool = Qnil;
+  return ret;
+}
+
+/*
+ * call-seq:
+ *    ServiceDescriptor.new(c_only_cookie, ptr) => ServiceDescriptor
+ *
+ * Creates a descriptor wrapper object.  May only be called from C.
+ */
+static VALUE ServiceDescriptor_initialize(VALUE _self, VALUE cookie,
+                                          VALUE descriptor_pool, VALUE ptr) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
+  self->servicedef = (const upb_ServiceDef*)NUM2ULL(ptr);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *     ServiceDescriptor.name => name
+ *
+ * Returns the name of this service.
+ */
+static VALUE ServiceDescriptor_name(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  return rb_str_maybe_null(upb_ServiceDef_FullName(self->servicedef));
+}
+
+/*
+ * call-seq:
+ *    ServiceDescriptor.file_descriptor
+ *
+ * Returns the FileDescriptor object this service belongs to.
+ */
+static VALUE ServiceDescriptor_file_descriptor(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  return get_filedef_obj(self->descriptor_pool,
+                         upb_ServiceDef_File(self->servicedef));
+}
+
+/*
+ * call-seq:
+ *     ServiceDescriptor.each(&block)
+ *
+ * Iterates over methods in this service, yielding to the block on each one.
+ */
+static VALUE ServiceDescriptor_each(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+
+  int n = upb_ServiceDef_MethodCount(self->servicedef);
+  for (int i = 0; i < n; i++) {
+    const upb_MethodDef* method = upb_ServiceDef_Method(self->servicedef, i);
+    VALUE obj = get_methoddef_obj(self->descriptor_pool, method);
+    rb_yield(obj);
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *     ServiceDescriptor.options => options
+ *
+ * Returns the `ServiceOptions` for this `ServiceDescriptor`.
+ */
+static VALUE ServiceDescriptor_options(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  const google_protobuf_ServiceOptions* opts =
+      upb_ServiceDef_Options(self->servicedef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized =
+      google_protobuf_ServiceOptions_serialize(opts, arena, &size);
+  VALUE service_options = decode_options(_self, "ServiceOptions", size,
+                                         serialized, self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return service_options;
+}
+
+/*
+ * call-seq:
+ *     ServiceDescriptor.to_proto => ServiceDescriptorProto
+ *
+ * Returns the `ServiceDescriptorProto` of this `ServiceDescriptor`.
+ */
+static VALUE ServiceDescriptor_to_proto(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_ServiceDescriptorProto* proto =
+      upb_ServiceDef_ToProto(self->servicedef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_ServiceDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::ServiceDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
+static void ServiceDescriptor_register(VALUE module) {
+  VALUE klass = rb_define_class_under(module, "ServiceDescriptor", rb_cObject);
+  rb_define_alloc_func(klass, ServiceDescriptor_alloc);
+  rb_define_method(klass, "initialize", ServiceDescriptor_initialize, 3);
+  rb_define_method(klass, "name", ServiceDescriptor_name, 0);
+  rb_define_method(klass, "each", ServiceDescriptor_each, 0);
+  rb_define_method(klass, "file_descriptor", ServiceDescriptor_file_descriptor,
+                   0);
+  rb_define_method(klass, "options", ServiceDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", ServiceDescriptor_to_proto, 0);
+  rb_include_module(klass, rb_mEnumerable);
+  rb_gc_register_address(&cServiceDescriptor);
+  cServiceDescriptor = klass;
+}
+
+// -----------------------------------------------------------------------------
+// MethodDescriptor
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  const upb_MethodDef* methoddef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  VALUE module;           // begins as nil
+  VALUE descriptor_pool;  // Owns the upb_MethodDef.
+} MethodDescriptor;
+
+static VALUE cMethodDescriptor = Qnil;
+
+static void MethodDescriptor_mark(void* _self) {
+  MethodDescriptor* self = _self;
+  rb_gc_mark(self->module);
+  rb_gc_mark(self->descriptor_pool);
+}
+
+static const rb_data_type_t MethodDescriptor_type = {
+    "Google::Protobuf::MethodDescriptor",
+    {MethodDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static MethodDescriptor* ruby_to_MethodDescriptor(VALUE val) {
+  MethodDescriptor* ret;
+  TypedData_Get_Struct(val, MethodDescriptor, &MethodDescriptor_type, ret);
+  return ret;
+}
+
+static VALUE MethodDescriptor_alloc(VALUE klass) {
+  MethodDescriptor* self = ALLOC(MethodDescriptor);
+  VALUE ret = TypedData_Wrap_Struct(klass, &MethodDescriptor_type, self);
+  self->methoddef = NULL;
+  self->module = Qnil;
+  self->descriptor_pool = Qnil;
+  return ret;
+}
+
+/*
+ * call-seq:
+ *    MethodDescriptor.new(c_only_cookie, ptr) => MethodDescriptor
+ *
+ * Creates a descriptor wrapper object.  May only be called from C.
+ */
+static VALUE MethodDescriptor_initialize(VALUE _self, VALUE cookie,
+                                         VALUE descriptor_pool, VALUE ptr) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
+  self->methoddef = (const upb_MethodDef*)NUM2ULL(ptr);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *     MethodDescriptor.name => name
+ *
+ * Returns the name of this method
+ */
+static VALUE MethodDescriptor_name(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return rb_str_maybe_null(upb_MethodDef_Name(self->methoddef));
+}
+
+/*
+ * call-seq:
+ *     MethodDescriptor.options => options
+ *
+ * Returns the `MethodOptions` for this `MethodDescriptor`.
+ */
+static VALUE MethodDescriptor_options(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  const google_protobuf_MethodOptions* opts =
+      upb_MethodDef_Options(self->methoddef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized =
+      google_protobuf_MethodOptions_serialize(opts, arena, &size);
+  VALUE method_options = decode_options(_self, "MethodOptions", size,
+                                        serialized, self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return method_options;
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.input_type => Descriptor
+ *
+ * Returns the `Descriptor` for the request message type of this method
+ */
+static VALUE MethodDescriptor_input_type(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  const upb_MessageDef* type = upb_MethodDef_InputType(self->methoddef);
+  return get_msgdef_obj(self->descriptor_pool, type);
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.output_type => Descriptor
+ *
+ * Returns the `Descriptor` for the response message type of this method
+ */
+static VALUE MethodDescriptor_output_type(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  const upb_MessageDef* type = upb_MethodDef_OutputType(self->methoddef);
+  return get_msgdef_obj(self->descriptor_pool, type);
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.client_streaming => bool
+ *
+ * Returns whether or not this is a streaming request method
+ */
+static VALUE MethodDescriptor_client_streaming(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return upb_MethodDef_ClientStreaming(self->methoddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *     MethodDescriptor.to_proto => MethodDescriptorProto
+ *
+ * Returns the `MethodDescriptorProto` of this `MethodDescriptor`.
+ */
+static VALUE MethodDescriptor_to_proto(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_MethodDescriptorProto* proto =
+      upb_MethodDef_ToProto(self->methoddef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_MethodDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::MethodDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.server_streaming => bool
+ *
+ * Returns whether or not this is a streaming response method
+ */
+static VALUE MethodDescriptor_server_streaming(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return upb_MethodDef_ServerStreaming(self->methoddef) ? Qtrue : Qfalse;
+}
+
+static void MethodDescriptor_register(VALUE module) {
+  VALUE klass = rb_define_class_under(module, "MethodDescriptor", rb_cObject);
+  rb_define_alloc_func(klass, MethodDescriptor_alloc);
+  rb_define_method(klass, "initialize", MethodDescriptor_initialize, 3);
+  rb_define_method(klass, "name", MethodDescriptor_name, 0);
+  rb_define_method(klass, "options", MethodDescriptor_options, 0);
+  rb_define_method(klass, "input_type", MethodDescriptor_input_type, 0);
+  rb_define_method(klass, "output_type", MethodDescriptor_output_type, 0);
+  rb_define_method(klass, "client_streaming", MethodDescriptor_client_streaming,
+                   0);
+  rb_define_method(klass, "server_streaming", MethodDescriptor_server_streaming,
+                   0);
+  rb_define_method(klass, "to_proto", MethodDescriptor_to_proto, 0);
+  rb_gc_register_address(&cMethodDescriptor);
+  cMethodDescriptor = klass;
+}
+
 static VALUE get_def_obj(VALUE _descriptor_pool, const void* ptr, VALUE klass) {
   DescriptorPool* descriptor_pool = ruby_to_DescriptorPool(_descriptor_pool);
   VALUE key = ULL2NUM((intptr_t)ptr);
@@ -1199,6 +1807,16 @@ static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_OneofDef* def) {
   return get_def_obj(descriptor_pool, def, cOneofDescriptor);
 }
 
+static VALUE get_servicedef_obj(VALUE descriptor_pool,
+                                const upb_ServiceDef* def) {
+  return get_def_obj(descriptor_pool, def, cServiceDescriptor);
+}
+
+static VALUE get_methoddef_obj(VALUE descriptor_pool,
+                               const upb_MethodDef* def) {
+  return get_def_obj(descriptor_pool, def, cMethodDescriptor);
+}
+
 // -----------------------------------------------------------------------------
 // Shared functions
 // -----------------------------------------------------------------------------
@@ -1274,6 +1892,8 @@ void Defs_register(VALUE module) {
   FieldDescriptor_register(module);
   OneofDescriptor_register(module);
   EnumDescriptor_register(module);
+  ServiceDescriptor_register(module);
+  MethodDescriptor_register(module);
 
   rb_gc_register_address(&c_only_cookie);
   c_only_cookie = rb_class_new_instance(0, NULL, rb_cObject);