google-protobuf 3.25.7 → 4.34.0

data/ext/google/protobuf_c/defs.c

@@ -7,7 +7,6 @@
 
 #include <ctype.h>
 #include <errno.h>
-#include <ruby/version.h>
 
 #include "convert.h"
 #include "message.h"
@@ -23,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
@@ -91,9 +93,15 @@ const upb_DefPool* DescriptorPool_GetSymtab(VALUE desc_pool_rb) {
   return pool->symtab;
 }
 
+/**
+ * ruby-doc: DescriptorPool
+ *
+ * A DescriptorPool is the registry of all known Protobuf descriptor objects.
+ *
+ */
+
 /*
- * call-seq:
- *     DescriptorPool.new => pool
+ * ruby-doc: DescriptorPool.new
  *
  * Creates a new, empty, descriptor pool.
  */
@@ -106,14 +114,22 @@ static VALUE DescriptorPool_alloc(VALUE klass) {
 
   RB_OBJ_WRITE(ret, &self->def_to_descriptor, rb_hash_new());
   self->symtab = upb_DefPool_New();
+
+  // Ruby treats all enums as open.
+  upb_DefPool_DisableClosedEnumChecking(self->symtab);
+
   return ObjectCache_TryAdd(self->symtab, ret);
 }
 
 /*
- * call-seq:
- *     DescriptorPool.add_serialized_file(serialized_file_proto)
+ * ruby-doc: DescriptorPool#add_serialized_file
+ *
+ * Adds the given serialized
+ * {https://protobuf.com/docs/descriptors#file-descriptors FileDescriptorProto}
+ * to the pool.
  *
- * Adds the given serialized FileDescriptorProto to the pool.
+ * @param serialized_file_proto [String]
+ * @return [FileDescriptor]
  */
 VALUE DescriptorPool_add_serialized_file(VALUE _self,
                                          VALUE serialized_file_proto) {
@@ -141,11 +157,14 @@ VALUE DescriptorPool_add_serialized_file(VALUE _self,
 }
 
 /*
- * call-seq:
- *     DescriptorPool.lookup(name) => descriptor
+ * ruby-doc: DescriptorPool#lookup
  *
- * Finds a Descriptor, EnumDescriptor or FieldDescriptor 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.
+ *
+ * @param name [String]
+ * @return [Descriptor,EnumDescriptor,FieldDescriptor,ServiceDescriptor]
  */
 static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
   DescriptorPool* self = ruby_to_DescriptorPool(_self);
@@ -153,6 +172,8 @@ static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
   const upb_MessageDef* msgdef;
   const upb_EnumDef* enumdef;
   const upb_FieldDef* fielddef;
+  const upb_ServiceDef* servicedef;
+  const upb_FileDef* filedef;
 
   msgdef = upb_DefPool_FindMessageByName(self->symtab, name_str);
   if (msgdef) {
@@ -169,17 +190,28 @@ static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
     return get_enumdef_obj(_self, enumdef);
   }
 
+  servicedef = upb_DefPool_FindServiceByName(self->symtab, name_str);
+  if (servicedef) {
+    return get_servicedef_obj(_self, servicedef);
+  }
+
+  filedef = upb_DefPool_FindFileByName(self->symtab, name_str);
+  if (filedef) {
+    return get_filedef_obj(_self, filedef);
+  }
+
   return Qnil;
 }
 
 /*
- * call-seq:
- *     DescriptorPool.generated_pool => descriptor_pool
+ * ruby-doc: DescriptorPool.generated_pool
+ *
+ * Class method that returns the global {DescriptorPool}. This is a singleton
+ * into which generated-code message and enum types are registered. The user may
+ * also register types in this pool for convenience so that they do not have to
+ * hold a reference to a private pool instance.
  *
- * Class method that returns the global DescriptorPool. This is a singleton into
- * which generated-code message and enum types are registered. The user may also
- * register types in this pool for convenience so that they do not have to hold
- * a reference to a private pool instance.
+ * @return [DescriptorPool]
  */
 static VALUE DescriptorPool_generated_pool(VALUE _self) {
   return generated_pool;
@@ -257,14 +289,32 @@ static VALUE decode_options(VALUE self, const char* option_type, int size,
   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, true);
+  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
+ * ruby-doc: Descriptor
+ *
+ * A Descriptor provides information about a given Protobuf definition.
+ */
+
+/*
+ * ruby-doc: Descriptor.initialize
  *
  * Creates a new, empty, message type descriptor. At a minimum, its name must be
  * set before it is added to a pool. It cannot be used to create messages until
@@ -302,10 +352,11 @@ static VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
 }
 
 /*
- * call-seq:
- *    Descriptor.file_descriptor
+ * ruby-doc: Descriptor#file_descriptor
+ *
+ * Returns the {FileDescriptor} object this message belongs to.
  *
- * Returns the FileDescriptor object this message belongs to.
+ * @return [FileDescriptor]
  */
 static VALUE Descriptor_file_descriptor(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -314,11 +365,12 @@ static VALUE Descriptor_file_descriptor(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Descriptor.name => name
+ * ruby-doc: Descriptor#name
  *
  * Returns the name of this message type as a fully-qualified string (e.g.,
  * My.Package.MessageType).
+ *
+ * @return [String]
  */
 static VALUE Descriptor_name(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -326,10 +378,12 @@ static VALUE Descriptor_name(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Descriptor.each(&block)
+ * ruby-doc: Descriptor#each
  *
  * Iterates over fields in this message type, yielding to the block on each one.
+ *
+ * @yield [FieldDescriptor]
+ * @return [nil]
  */
 static VALUE Descriptor_each(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -344,11 +398,13 @@ static VALUE Descriptor_each(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Descriptor.lookup(name) => FieldDescriptor
+ * ruby-doc: Descriptor#lookup
  *
  * Returns the field descriptor for the field with the given name, if present,
  * or nil if none.
+ *
+ * @param name [String]
+ * @return [FieldDescriptor]
  */
 static VALUE Descriptor_lookup(VALUE _self, VALUE name) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -361,11 +417,13 @@ static VALUE Descriptor_lookup(VALUE _self, VALUE name) {
 }
 
 /*
- * call-seq:
- *     Descriptor.each_oneof(&block) => nil
+ * ruby-doc: Descriptor#each_oneof
  *
  * Invokes the given block for each oneof in this message type, passing the
- * corresponding OneofDescriptor.
+ * corresponding {OneofDescriptor}.
+ *
+ * @yield [OneofDescriptor]
+ * @return [nil]
  */
 static VALUE Descriptor_each_oneof(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -380,11 +438,13 @@ static VALUE Descriptor_each_oneof(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Descriptor.lookup_oneof(name) => OneofDescriptor
+ * ruby-doc: Descriptor#lookup_oneof
  *
  * Returns the oneof descriptor for the oneof with the given name, if present,
  * or nil if none.
+ *
+ * @param name [String]
+ * @return [OneofDescriptor]
  */
 static VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -397,10 +457,11 @@ static VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
 }
 
 /*
- * call-seq:
- *     Descriptor.msgclass => message_klass
+ * ruby-doc: Descriptor#msgclass
  *
  * Returns the Ruby class created for this message type.
+ *
+ * @return [Class<Google::Protobuf::AbstractMessage>]
  */
 static VALUE Descriptor_msgclass(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -411,10 +472,13 @@ static VALUE Descriptor_msgclass(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Descriptor.options => options
+ * ruby-doc: Descriptor#options
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L571
+ * MessageOptions} for this {Descriptor}.
  *
- * Returns the `MessageOptions` for this `Descriptor`.
+ * @return [MessageOptions]
  */
 static VALUE Descriptor_options(VALUE _self) {
   Descriptor* self = ruby_to_Descriptor(_self);
@@ -430,6 +494,30 @@ static VALUE Descriptor_options(VALUE _self) {
   return message_options;
 }
 
+/*
+ * ruby-doc: Descriptor#to_proto
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L147
+ * DescriptorProto} of this {Descriptor}.
+ *
+ * @return [DescriptorProto]
+ */
+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);
@@ -442,6 +530,7 @@ static void Descriptor_register(VALUE module) {
   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;
@@ -485,11 +574,17 @@ static VALUE FileDescriptor_alloc(VALUE klass) {
   return ret;
 }
 
+/**
+ * ruby-doc: FileDescriptor
+ *
+ * A FileDescriptor provides information about all Protobuf definitions in a
+ * particular file.
+ */
+
 /*
- * call-seq:
- *     FileDescriptor.new => file
+ * ruby-doc: FileDescriptor#initialize
  *
- * 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,
@@ -508,10 +603,11 @@ static VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
 }
 
 /*
- * call-seq:
- *     FileDescriptor.name => name
+ * ruby-doc: FileDescriptor#name
  *
  * Returns the name of the file.
+ *
+ * @return [String]
  */
 static VALUE FileDescriptor_name(VALUE _self) {
   FileDescriptor* self = ruby_to_FileDescriptor(_self);
@@ -520,32 +616,13 @@ static VALUE FileDescriptor_name(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FileDescriptor.syntax => syntax
- *
- * Returns this file descriptors syntax.
+ * ruby-doc: FileDescriptor#options
  *
- * Valid syntax versions are:
- *     :proto2 or :proto3.
- */
-static VALUE FileDescriptor_syntax(VALUE _self) {
-  FileDescriptor* self = ruby_to_FileDescriptor(_self);
-
-  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;
-  }
-}
-
-/*
- * call-seq:
- *     FileDescriptor.options => options
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L442
+ * FileOptions} for this {FileDescriptor}.
  *
- * Returns the `FileOptions` for this `FileDescriptor`.
+ * @return [FileOptions]
  */
 static VALUE FileDescriptor_options(VALUE _self) {
   FileDescriptor* self = ruby_to_FileDescriptor(_self);
@@ -559,13 +636,40 @@ static VALUE FileDescriptor_options(VALUE _self) {
   return file_options;
 }
 
+/*
+ * ruby-doc: FileDescriptor#to_proto
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L104
+ * FileDescriptorProto} of this {FileDescriptor}.
+ *
+ * @return [FileDescriptorProto]
+ */
+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);
+
+  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) {
   VALUE klass = rb_define_class_under(module, "FileDescriptor", rb_cObject);
   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;
 }
@@ -600,9 +704,15 @@ static FieldDescriptor* ruby_to_FieldDescriptor(VALUE val) {
   return ret;
 }
 
+/**
+ * ruby-doc: FieldDescriptor
+ *
+ * A FieldDescriptor provides information about the Protobuf definition of a
+ * field inside a {Descriptor}.
+ */
+
 /*
- * call-seq:
- *     FieldDescriptor.new => field
+ * ruby-doc: FieldDescriptor#initialize
  *
  * Returns a new field descriptor. Its name, type, etc. must be set before it is
  * added to a message type.
@@ -636,10 +746,11 @@ static VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.name => name
+ * ruby-doc: FieldDescriptor#name
  *
  * Returns the name of this field.
+ *
+ * @return [String]
  */
 static VALUE FieldDescriptor_name(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -704,14 +815,15 @@ static VALUE descriptortype_to_ruby(upb_FieldType type) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.type => type
+ * ruby-doc: FieldDescriptor#type
  *
  * Returns this field's type, as a Ruby symbol, or nil if not yet set.
  *
  * Valid field types are:
  *     :int32, :int64, :uint32, :uint64, :float, :double, :bool, :string,
  *     :bytes, :message.
+ *
+ * @return [Symbol]
  */
 static VALUE FieldDescriptor__type(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -719,15 +831,16 @@ static VALUE FieldDescriptor__type(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.default => default
+ * ruby-doc: FieldDescriptor#default
  *
  * Returns this field's default, as a Ruby object, or nil if not yet set.
+ *
+ * @return [Object,nil]
  */
 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)) {
@@ -737,10 +850,57 @@ static VALUE FieldDescriptor_default(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.json_name => json_name
+ * ruby-doc: FieldDescriptor.has_presence?
+ *
+ * Returns whether this field tracks presence.
+ *
+ * @return [Boolean]
+ */
+static VALUE FieldDescriptor_has_presence(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_HasPresence(self->fielddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * ruby-doc: FieldDescriptor#required?
+ *
+ * Returns whether this is a required field.
+ *
+ * @return [Boolean]
+ */
+static VALUE FieldDescriptor_is_required(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_IsRequired(self->fielddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * ruby-doc: FieldDescriptor#repeated?
+ *
+ * Returns whether this is a repeated field.
+ * @return [Boolean]
+ */
+static VALUE FieldDescriptor_is_repeated(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_IsRepeated(self->fielddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * ruby-doc: FieldDescriptor#is_packed?
+ *
+ * Returns whether this is a repeated field that uses packed encoding.
+ * @return [Boolean]
+ */
+static VALUE FieldDescriptor_is_packed(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_IsPacked(self->fielddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * ruby-doc: FieldDescriptor#json_name
  *
  * Returns this field's json_name, as a Ruby string, or nil if not yet set.
+ *
+ * @return [String,nil]
  */
 static VALUE FieldDescriptor_json_name(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -750,13 +910,14 @@ static VALUE FieldDescriptor_json_name(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.label => label
+ * ruby-doc: FieldDescriptor#label
  *
  * Returns this field's label (i.e., plurality), as a Ruby symbol.
- *
  * Valid field labels are:
- *     :optional, :repeated
+ *   :optional, :repeated
+ *
+ * @return [Symbol]
+ * @deprecated Use {#repeated?} or {#required?} instead.
  */
 static VALUE FieldDescriptor_label(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -776,10 +937,11 @@ static VALUE FieldDescriptor_label(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.number => number
+ * ruby-doc: FieldDescriptor#number
  *
  * Returns the tag number for this field.
+ *
+ * @return [Integer]
  */
 static VALUE FieldDescriptor_number(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -787,13 +949,14 @@ static VALUE FieldDescriptor_number(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.submsg_name => submsg_name
+ * ruby-doc: FieldDescriptor#submsg_name
  *
  * Returns the name of the message or enum type corresponding to this field, if
  * it is a message or enum field (respectively), or nil otherwise. This type
  * name will be resolved within the context of the pool to which the containing
  * message type is added.
+ *
+ * @return [String,nil]
  */
 static VALUE FieldDescriptor_submsg_name(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -810,13 +973,14 @@ static VALUE FieldDescriptor_submsg_name(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.subtype => message_or_enum_descriptor
+ * ruby-doc: FieldDescriptor#subtype
  *
  * Returns the message or enum descriptor corresponding to this field's type if
  * it is a message or enum field, respectively, or nil otherwise. Cannot be
  * called *until* the containing message type is added to a pool (and thus
  * resolved).
+ *
+ * @return [Descriptor,EnumDescriptor,nil]
  */
 static VALUE FieldDescriptor_subtype(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -833,11 +997,13 @@ static VALUE FieldDescriptor_subtype(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.get(message) => value
+ * ruby-doc: FieldDescriptor#get
  *
  * Returns the value set for this field on the given message. Raises an
  * exception if message is of the wrong type.
+ *
+ * @param message [AbstractMessage]
+ * @return [Object]
  */
 static VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -853,11 +1019,13 @@ static VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.has?(message) => boolean
+ * ruby-doc: FieldDescriptor.has?
  *
  * Returns whether the value is set on the given message. Raises an
  * exception when calling for fields that do not have presence.
+ *
+ * @param message [AbstractMessage]
+ * @return [Boolean]
  */
 static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -874,10 +1042,12 @@ static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.clear(message)
+ * ruby-doc: FieldDescriptor#clear
  *
  * Clears the field from the message if it's set.
+ *
+ * @param message [AbstractMessage]
+ * @return [nil]
  */
 static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -893,12 +1063,14 @@ static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.set(message, value)
+ * ruby-doc: FieldDescriptor#set
  *
  * Sets the value corresponding to this field to the given value on the given
  * message. Raises an exception if message is of the wrong type. Performs the
  * ordinary type-checks for field setting.
+ *
+ * @param message [AbstractMessage]
+ * @param value [Object]
  */
 static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -918,10 +1090,13 @@ static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
 }
 
 /*
- * call-seq:
- *     FieldDescriptor.options => options
+ * ruby-doc: FieldDescriptor#options
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L656
+ * FieldOptions} for this {FieldDescriptor}.
  *
- * Returns the `FieldOptions` for this `FieldDescriptor`.
+ * @return [FieldOptions]
  */
 static VALUE FieldDescriptor_options(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
@@ -936,6 +1111,30 @@ static VALUE FieldDescriptor_options(VALUE _self) {
   return field_options;
 }
 
+/*
+ * ruby-doc: FieldDescriptor#to_proto
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L236
+ * FieldDescriptorProto} of this {FieldDescriptor}.
+ *
+ * @return [FieldDescriptorProto]
+ */
+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);
@@ -943,6 +1142,10 @@ 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, "required?", FieldDescriptor_is_required, 0);
+  rb_define_method(klass, "repeated?", FieldDescriptor_is_repeated, 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);
@@ -953,6 +1156,7 @@ static void FieldDescriptor_register(VALUE module) {
   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;
 }
@@ -987,9 +1191,15 @@ static OneofDescriptor* ruby_to_OneofDescriptor(VALUE val) {
   return ret;
 }
 
+/**
+ * ruby-doc: OneofDescriptor
+ *
+ * A OneofDescriptor provides information about the Protobuf definition of a
+ * oneof inside a {Descriptor}.
+ */
+
 /*
- * call-seq:
- *     OneofDescriptor.new => oneof_descriptor
+ * ruby-doc: OneofDescriptor#initialize
  *
  * Creates a new, empty, oneof descriptor. The oneof may only be modified prior
  * to being added to a message descriptor which is subsequently added to a pool.
@@ -1024,10 +1234,11 @@ static VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
 }
 
 /*
- * call-seq:
- *     OneofDescriptor.name => name
+ * ruby-doc: OneofDescriptor#name
  *
  * Returns the name of this oneof.
+ *
+ * @return [String]
  */
 static VALUE OneofDescriptor_name(VALUE _self) {
   OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
@@ -1035,10 +1246,12 @@ static VALUE OneofDescriptor_name(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     OneofDescriptor.each(&block) => nil
+ * ruby-doc: OneofDescriptor#each
  *
  * Iterates through fields in this oneof, yielding to the block on each one.
+ *
+ * @yield [FieldDescriptor]
+ * @return [nil]
  */
 static VALUE OneofDescriptor_each(VALUE _self) {
   OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
@@ -1053,10 +1266,13 @@ static VALUE OneofDescriptor_each(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     OneofDescriptor.options => options
+ * ruby-doc: OneofDescriptor#options
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L824
+ * OneofOptions} for this {OneofDescriptor}.
  *
- * Returns the `OneofOptions` for this `OneofDescriptor`.
+ * @return [OneofOptions]
  */
 static VALUE OneOfDescriptor_options(VALUE _self) {
   OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
@@ -1071,6 +1287,30 @@ static VALUE OneOfDescriptor_options(VALUE _self) {
   return oneof_options;
 }
 
+/*
+ * ruby-doc: OneofDescriptor#to_proto
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L343
+ * OneofDescriptorProto} of this {OneofDescriptor}.
+ *
+ * @return [OneofDescriptorProto]
+ */
+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);
@@ -1078,6 +1318,7 @@ static void OneofDescriptor_register(VALUE module) {
   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;
@@ -1130,6 +1371,13 @@ const upb_EnumDef* EnumDescriptor_GetEnumDef(VALUE enum_desc_rb) {
   return desc->enumdef;
 }
 
+/**
+ * ruby-doc: EnumDescriptor
+ *
+ * An EnumDescriptor provides information about the Protobuf definition of an
+ * enum inside a {Descriptor}.
+ */
+
 /*
  * call-seq:
  *    EnumDescriptor.new(c_only_cookie, ptr) => EnumDescriptor
@@ -1152,10 +1400,11 @@ static VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
 }
 
 /*
- * call-seq:
- *    EnumDescriptor.file_descriptor
+ * ruby-doc: EnumDescriptor#file_descriptor
+ *
+ * Returns the {FileDescriptor} object this enum belongs to.
  *
- * Returns the FileDescriptor object this enum belongs to.
+ * @return [FileDescriptor]
  */
 static VALUE EnumDescriptor_file_descriptor(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
@@ -1164,10 +1413,23 @@ static VALUE EnumDescriptor_file_descriptor(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     EnumDescriptor.name => name
+ * ruby-doc: EnumDescriptor#is_closed?
+ *
+ * Returns whether this enum is open or closed.
+ *
+ * @return [Boolean]
+ */
+static VALUE EnumDescriptor_is_closed(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
+  return upb_EnumDef_IsClosed(self->enumdef) ? Qtrue : Qfalse;
+}
+
+/*
+ * ruby-doc: EnumDescriptor#name
  *
  * Returns the name of this enum type.
+ *
+ * @return [String]
  */
 static VALUE EnumDescriptor_name(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
@@ -1175,11 +1437,13 @@ static VALUE EnumDescriptor_name(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     EnumDescriptor.lookup_name(name) => value
+ * ruby-doc: EnumDescriptor#lookup_name
  *
  * Returns the numeric value corresponding to the given key name (as a Ruby
  * symbol), or nil if none.
+ *
+ * @param name [Symbol]
+ * @return [Integer,nil]
  */
 static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
@@ -1194,11 +1458,13 @@ static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
 }
 
 /*
- * call-seq:
- *     EnumDescriptor.lookup_value(name) => value
+ * ruby-doc: EnumDescriptor#lookup_value
  *
  * Returns the key name (as a Ruby symbol) corresponding to the integer value,
  * or nil if none.
+ *
+ * @param name [Integer]
+ * @return [Symbol,nil]
  */
 static VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
@@ -1213,11 +1479,13 @@ static VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
 }
 
 /*
- * call-seq:
- *     EnumDescriptor.each(&block)
+ * ruby-doc: EnumDescriptor#each
  *
  * Iterates over key => value mappings in this enum's definition, yielding to
  * the block with (key, value) arguments for each one.
+ *
+ * @yield [Symbol, Integer]
+ * @return [nil]
  */
 static VALUE EnumDescriptor_each(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
@@ -1234,10 +1502,11 @@ static VALUE EnumDescriptor_each(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     EnumDescriptor.enummodule => module
+ * ruby-doc: EnumDescriptor#enummodule
  *
  * Returns the Ruby module corresponding to this enum type.
+ *
+ * @return [Module]
  */
 static VALUE EnumDescriptor_enummodule(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
@@ -1248,10 +1517,13 @@ static VALUE EnumDescriptor_enummodule(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     EnumDescriptor.options => options
+ * ruby-doc: EnumDescriptor#options
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L838
+ * EnumOptions} for this {EnumDescriptor}.
  *
- * Returns the `EnumOptions` for this `EnumDescriptor`.
+ * @return [EnumOptions]
  */
 static VALUE EnumDescriptor_options(VALUE _self) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
@@ -1265,6 +1537,31 @@ static VALUE EnumDescriptor_options(VALUE _self) {
   return enum_options;
 }
 
+/*
+ * ruby-doc: EnumDescriptor#to_proto
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L349
+ * EnumDescriptorProto} of this {EnumDescriptor}.
+ * @return [EnumDescriptorProto]
+ */
+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);
@@ -1275,12 +1572,384 @@ 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;
+}
+
+/**
+ * ruby-doc: ServiceDescriptor
+ *
+ * A ServiceDescriptor provides information about the Protobuf definition of an
+ * RPC service.
+ */
+
+/*
+ * 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;
+}
+
+/*
+ * ruby-doc: ServiceDescriptor#name
+ *
+ * Returns the name of this service.
+ *
+ * @return [String]
+ */
+static VALUE ServiceDescriptor_name(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  return rb_str_maybe_null(upb_ServiceDef_FullName(self->servicedef));
+}
+
+/*
+ * ruby-doc: ServiceDescriptor#file_descriptor
+ *
+ * Returns the {FileDescriptor} object this service belongs to.
+ * @return [FileDescriptor]
+ */
+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));
+}
+
+/*
+ * ruby-doc: ServiceDescriptor#each
+ *
+ * Iterates over methods in this service, yielding to the block on each one.
+ *
+ * @yield [MethodDescriptor]
+ * @return [nil]
+ */
+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;
+}
+
+/*
+ * ruby-doc: ServiceDescriptor#options
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L901
+ * ServiceOptions} for this {ServiceDescriptor}.
+ *
+ * @return [ServiceOptions]
+ */
+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;
+}
+
+/*
+ * ruby-doc: ServiceDescriptor#to_proto
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L386
+ * ServiceDescriptorProto} of this {ServiceDescriptor}.
+ *
+ * @return [ServiceDescriptorProto]
+ */
+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;
+}
+
+/**
+ * ruby-doc: MethodDescriptor
+ *
+ * A MethodDescriptor provides information about the Protobuf definition of a
+ * method inside an RPC service.
+ */
+
+/*
+ * 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;
+}
+
+/*
+ * ruby-doc: MethodDescriptor#name
+ *
+ * Returns the name of this method
+ *
+ * @return [String]
+ */
+static VALUE MethodDescriptor_name(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return rb_str_maybe_null(upb_MethodDef_Name(self->methoddef));
+}
+
+/*
+ * ruby-doc: MethodDescriptor#options
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L927
+ * MethodOptions} for this {MethodDescriptor}.
+ *
+ * @return [MethodOptions]
+ */
+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;
+}
+
+/*
+ * ruby-doc: MethodDescriptor#input_type
+ *
+ * Returns the {Descriptor} for the request message type of this method
+ *
+ * @return [Descriptor]
+ */
+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);
+}
+
+/*
+ * ruby-doc: MethodDescriptor#output_type
+ *
+ * Returns the {Descriptor} for the response message type of this method
+ *
+ * @return [Descriptor]
+ */
+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);
+}
+
+/*
+ * ruby-doc: MethodDescriptor#client_streaming
+ *
+ * Returns whether or not this is a streaming request method
+ *
+ * @return [Boolean]
+ */
+static VALUE MethodDescriptor_client_streaming(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return upb_MethodDef_ClientStreaming(self->methoddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * ruby-doc: MethodDescriptor#to_proto
+ *
+ * Returns the
+ * {https://github.com/protocolbuffers/protobuf/blob/v30.2/src/google/protobuf/descriptor.proto#L394
+ * MethodDescriptorProto} of this {MethodDescriptor}.
+ *
+ * @return [MethodDescriptorProto]
+ */
+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;
+}
+
+/*
+ * ruby-doc: MethodDescriptor#server_streaming
+ *
+ * Returns whether or not this is a streaming response method
+ *
+ * @return [Boolean]
+ */
+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);
@@ -1322,6 +1991,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
 // -----------------------------------------------------------------------------
@@ -1397,6 +2076,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);