google-protobuf 4.29.1 → 4.33.1

data/ext/google/protobuf_c/message.c

@@ -362,7 +362,8 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
       if (!upb_FieldDef_HasPresence(f)) {
         rb_raise(rb_eRuntimeError, "Field does not have presence.");
       }
-      return upb_Message_HasFieldByDef(Message_Get(_self, NULL), f);
+      return upb_Message_HasFieldByDef(Message_Get(_self, NULL), f) ? Qtrue
+                                                                    : Qfalse;
     case METHOD_WRAPPER_GETTER: {
       Message* self = ruby_to_Message(_self);
       if (upb_Message_HasFieldByDef(self->msg, f)) {
@@ -397,7 +398,7 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
       upb_MessageValue msgval =
           upb_Message_GetFieldByDef(Message_Get(_self, NULL), f);
 
-      if (upb_FieldDef_Label(f) == kUpb_Label_Repeated) {
+      if (upb_FieldDef_IsRepeated(f)) {
         // Map repeated fields to a new type with ints
         VALUE arr = rb_ary_new();
         size_t i, n = upb_Array_Size(msgval.array_val);
@@ -419,11 +420,10 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
 }
 
 /*
- * call-seq:
- *     Message.method_missing(*args)
+ * ruby-doc: AbstractMessage
  *
- * Provides accessors and setters and methods to clear and check for presence of
- * message fields according to their field names.
+ * The {AbstractMessage} class is the parent class for all Protobuf messages,
+ * and is generated from C code.
  *
  * For any field whose name does not conflict with a built-in method, an
  * accessor is provided with the same name as the field, and a setter is
@@ -591,7 +591,7 @@ static void Message_InitFieldFromValue(upb_Message* msg, const upb_FieldDef* f,
   if (upb_FieldDef_IsMap(f)) {
     upb_Map* map = upb_Message_Mutable(msg, f, arena).map;
     Map_InitFromValue(map, f, val, arena);
-  } else if (upb_FieldDef_Label(f) == kUpb_Label_Repeated) {
+  } else if (upb_FieldDef_IsRepeated(f)) {
     upb_Array* arr = upb_Message_Mutable(msg, f, arena).array;
     RepeatedField_InitFromValue(arr, f, val, arena);
   } else if (upb_FieldDef_IsSubMessage(f)) {
@@ -652,16 +652,12 @@ void Message_InitFromValue(upb_Message* msg, const upb_MessageDef* m, VALUE val,
 }
 
 /*
- * call-seq:
- *     Message.new(kwargs) => new_message
+ * ruby-doc: AbstractMessage#initialize
  *
  * Creates a new instance of the given message class. Keyword arguments may be
  * provided with keywords corresponding to field names.
  *
- * Note that no literal Message class exists. Only concrete classes per message
- * type exist, as provided by the #msgclass method on Descriptors after they
- * have been added to a pool. The method definitions described here on the
- * Message class are provided on each concrete message class.
+ * @param kwargs the list of field keys and values.
  */
 static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -683,10 +679,11 @@ static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.dup => new_message
+ * ruby-doc: AbstractMessage#dup
  *
  * Performs a shallow copy of this message and returns the new copy.
+ *
+ * @return [AbstractMessage]
  */
 static VALUE Message_dup(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -699,13 +696,15 @@ static VALUE Message_dup(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.==(other) => boolean
+ * ruby-doc: AbstractMessage#==
  *
  * Performs a deep comparison of this message with another. Messages are equal
  * if they have the same type and if each field is equal according to the :==
  * method's semantics (a more efficient comparison may actually be done if the
  * field is of a primitive type).
+ *
+ * @param other [AbstractMessage]
+ * @return [Boolean]
  */
 static VALUE Message_eq(VALUE _self, VALUE _other) {
   if (CLASS_OF(_self) != CLASS_OF(_other)) return Qfalse;
@@ -734,10 +733,11 @@ uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
 }
 
 /*
- * call-seq:
- *     Message.hash => hash_value
+ * ruby-doc: AbstractMessage#hash
  *
  * Returns a hash value that represents this message's field values.
+ *
+ * @return [Integer]
  */
 static VALUE Message_hash(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -748,12 +748,13 @@ static VALUE Message_hash(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.inspect => string
+ * ruby-doc: AbstractMessage#inspect
  *
  * Returns a human-readable string representing this message. It will be
  * formatted as "<MessageType: field1: value1, field2: value2, ...>". Each
  * field's value is represented according to its own #inspect method.
+ *
+ * @return [String]
  */
 static VALUE Message_inspect(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -829,10 +830,11 @@ VALUE Scalar_CreateHash(upb_MessageValue msgval, TypeInfo type_info) {
 }
 
 /*
- * call-seq:
- *     Message.to_h => {}
+ * ruby-doc: AbstractMessage#to_h
  *
  * Returns the message as a Ruby Hash object, with keys as symbols.
+ *
+ * @return [Hash]
  */
 static VALUE Message_to_h(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -840,12 +842,13 @@ static VALUE Message_to_h(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.frozen? => bool
+ * ruby-doc: AbstractMessage#frozen?
  *
  * Returns true if the message is frozen in either Ruby or the underlying
  * representation. Freezes the Ruby message object if it is not already frozen
  * in Ruby but it is frozen in the underlying representation.
+ *
+ * @return [Boolean]
  */
 VALUE Message_frozen(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -860,11 +863,12 @@ VALUE Message_frozen(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.freeze => self
+ * ruby-doc: AbstractMessage#freeze
  *
  * Freezes the message object. We have to intercept this so we can freeze the
  * underlying representation, not just the Ruby wrapper.
+ *
+ * @return [self]
  */
 VALUE Message_freeze(VALUE _self) {
   Message* self = ruby_to_Message(_self);
@@ -881,11 +885,13 @@ VALUE Message_freeze(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.[](index) => value
+ * ruby-doc: AbstractMessage#[]
  *
  * Accesses a field's value by field name. The provided field name should be a
  * string.
+ *
+ * @param index [Integer]
+ * @return [Object]
  */
 static VALUE Message_index(VALUE _self, VALUE field_name) {
   Message* self = ruby_to_Message(_self);
@@ -902,11 +908,14 @@ static VALUE Message_index(VALUE _self, VALUE field_name) {
 }
 
 /*
- * call-seq:
- *     Message.[]=(index, value)
+ * ruby-doc: AbstractMessage#[]=
  *
  * Sets a field's value by field name. The provided field name should be a
  * string.
+ *
+ * @param index [Integer]
+ * @param value [Object]
+ * @return [nil]
  */
 static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
   Message* self = ruby_to_Message(_self);
@@ -928,14 +937,16 @@ static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
 }
 
 /*
- * call-seq:
- *     MessageClass.decode(data, options) => message
+ * ruby-doc: AbstractMessage.decode
  *
  * Decodes the given data (as a string containing bytes in protocol buffers wire
  * format) under the interpretation given by this message class's definition
  * and returns a message object with the corresponding field values.
- * @param options [Hash] options for the decoder
- *  recursion_limit: set to maximum decoding depth for message (default is 64)
+ * @param data [String]
+ * @param options [Hash]
+ * @option recursion_limit [Integer] set to maximum decoding depth for message
+ * (default is 64)
+ * @return [AbstractMessage]
  */
 static VALUE Message_decode(int argc, VALUE* argv, VALUE klass) {
   VALUE data = argv[0];
@@ -988,16 +999,17 @@ VALUE Message_decode_bytes(int size, const char* bytes, int options,
 }
 
 /*
- * call-seq:
- *     MessageClass.decode_json(data, options = {}) => message
+ * ruby-doc: AbstractMessage.decode_json
  *
  * Decodes the given data (as a string containing bytes in protocol buffers wire
  * format) under the interpretration given by this message class's definition
  * and returns a message object with the corresponding field values.
  *
- *  @param options [Hash] options for the decoder
- *   ignore_unknown_fields: set true to ignore unknown fields (default is to
- *   raise an error)
+ * @param data [String]
+ * @param options [Hash]
+ * @option ignore_unknown_fields [Boolean] set true to ignore unknown fields
+ * (default is to raise an error)
+ * @return [AbstractMessage]
  */
 static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
   VALUE data = argv[0];
@@ -1046,9 +1058,6 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
   switch (result) {
     case kUpb_JsonDecodeResult_Ok:
       break;
-    case kUpb_JsonDecodeResult_OkWithEmptyStringNumerics:
-      rb_warn("%s", upb_Status_ErrorMessage(&status));
-      break;
     case kUpb_JsonDecodeResult_Error:
       rb_raise(cParseError, "Error occurred during parsing: %s",
                upb_Status_ErrorMessage(&status));
@@ -1059,13 +1068,16 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     MessageClass.encode(msg, options) => bytes
+ * ruby-doc: AbstractMessage.encode
  *
  * Encodes the given message object to its serialized form in protocol buffers
  * wire format.
- * @param options [Hash] options for the encoder
- *  recursion_limit: set to maximum encoding depth for message (default is 64)
+ *
+ * @param msg [AbstractMessage]
+ * @param options [Hash]
+ * @option recursion_limit [Integer] set to maximum encoding depth for message
+ * (default is 64)
+ * @return [String]
  */
 static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
   Message* msg = ruby_to_Message(argv[0]);
@@ -1112,14 +1124,17 @@ static VALUE Message_encode(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     MessageClass.encode_json(msg, options = {}) => json_string
+ * ruby-doc: AbstractMessage.encode_json
  *
  * Encodes the given message object into its serialized JSON representation.
- * @param options [Hash] options for the decoder
- *  preserve_proto_fieldnames: set true to use original fieldnames (default is
- * to camelCase) emit_defaults: set true to emit 0/false values (default is to
- * omit them)
+ *
+ * @param msg [AbstractMessage]
+ * @param options [Hash]
+ * @option preserve_proto_fieldnames [Boolean] set true to use original
+ * fieldnames (default is to camelCase)
+ * @option emit_defaults [Boolean] set true to emit 0/false values (default is
+ * to omit them)
+ * @return [String]
  */
 static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
   Message* msg = ruby_to_Message(argv[0]);
@@ -1187,11 +1202,12 @@ static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
 }
 
 /*
- * call-seq:
- *     Message.descriptor => descriptor
+ * ruby-doc: AbstractMessage.descriptor
  *
  * Class method that returns the Descriptor instance corresponding to this
  * message class's type.
+ *
+ * @return [Descriptor]
  */
 static VALUE Message_descriptor(VALUE klass) {
   return rb_ivar_get(klass, descriptor_instancevar_interned);
@@ -1214,12 +1230,26 @@ VALUE build_class_from_descriptor(VALUE descriptor) {
   return klass;
 }
 
+/* ruby-doc: Enum
+ *
+ * There isn't really a concrete `Enum` module generated by Protobuf. Instead,
+ * you can use this documentation as an indicator of methods that are defined on
+ * each `Enum` module that is generated. E.g. if you have:
+ *
+ *   enum my_enum_type
+ *
+ * in your Proto file and generate Ruby code, a module
+ * called `MyEnumType` will be generated with the following methods available.
+ */
+
 /*
- * call-seq:
- *     Enum.lookup(number) => name
+ * ruby-doc: Enum.lookup
  *
  * This module method, provided on each generated enum module, looks up an enum
  * value by number and returns its name as a Ruby symbol, or nil if not found.
+ *
+ * @param number [Integer]
+ * @return [String]
  */
 static VALUE enum_lookup(VALUE self, VALUE number) {
   int32_t num = NUM2INT(number);
@@ -1234,11 +1264,13 @@ static VALUE enum_lookup(VALUE self, VALUE number) {
 }
 
 /*
- * call-seq:
- *     Enum.resolve(name) => number
+ * ruby-doc: Enum.resolve
  *
  * This module method, provided on each generated enum module, looks up an enum
  * value by name (as a Ruby symbol) and returns its name, or nil if not found.
+ *
+ * @param name [String]
+ * @return [Integer]
  */
 static VALUE enum_resolve(VALUE self, VALUE sym) {
   const char* name = rb_id2name(SYM2ID(sym));
@@ -1253,11 +1285,13 @@ static VALUE enum_resolve(VALUE self, VALUE sym) {
 }
 
 /*
- * call-seq:
- *     Enum.descriptor
+ * ruby-doc: Enum.descriptor
  *
  * This module method, provided on each generated enum module, returns the
- * EnumDescriptor corresponding to this enum type.
+ * {EnumDescriptor} corresponding to this enum type.
+ *
+ * @return [EnumDescriptor]
+ *
  */
 static VALUE enum_descriptor(VALUE self) {
   return rb_ivar_get(self, descriptor_instancevar_interned);

data/ext/google/protobuf_c/protobuf.c

@@ -183,7 +183,7 @@ const rb_data_type_t Arena_type = {
 };
 
 static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
-                                size_t size) {
+                                size_t size, size_t *actual_size) {
   if (size == 0) {
     xfree(ptr);
     return NULL;
@@ -286,7 +286,8 @@ VALUE ObjectCache_Get(const void *key) {
 static VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb) {
   const upb_MessageDef *m;
   upb_Message *msg = Message_GetMutable(msg_rb, &m);
-  if (!upb_Message_DiscardUnknown(msg, m, 128)) {
+  const upb_DefPool* ext_pool = upb_FileDef_Pool(upb_MessageDef_File(m));
+  if (!upb_Message_DiscardUnknown(msg, m, ext_pool, 128)) {
     rb_raise(rb_eRuntimeError, "Messages nested too deeply.");
   }
 

data/ext/google/protobuf_c/protobuf.h

@@ -16,12 +16,6 @@
 #undef NDEBUG
 #endif
 
-#include <ruby/version.h>
-
-#if RUBY_API_VERSION_CODE < 20700
-#error Protobuf requires Ruby >= 2.7
-#endif
-
 #include <assert.h>  // Must be included after the NDEBUG logic above.
 #include <ruby/encoding.h>
 #include <ruby/vm.h>
@@ -103,6 +97,4 @@ void Protobuf_CheckNotFrozen(VALUE val, bool upb_frozen);
 
 #define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y))
 
-#define UPB_UNUSED(var) (void)var
-
 #endif  // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__

data/ext/google/protobuf_c/repeated_field.c

@@ -192,13 +192,20 @@ static VALUE RepeatedField_subarray(RepeatedField* self, long beg, long len) {
   return ary;
 }
 
+/**
+ * ruby-doc: RepeatedField
+ *
+ */
+
 /*
- * call-seq:
- *     RepeatedField.each(&block)
+ * ruby-doc: RepeatedField#each
  *
  * Invokes the block once for each element of the repeated field. RepeatedField
  * also includes Enumerable; combined with this method, the repeated field thus
  * acts like an ordinary Ruby sequence.
+ *
+ * @yield [Object]
+ * @return [self]
  */
 static VALUE RepeatedField_each(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -214,10 +221,12 @@ static VALUE RepeatedField_each(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.[](index) => value
+ * ruby-doc: RepeatedField#[]
  *
  * Accesses the element at the given index. Returns nil on out-of-bounds
+ *
+ * @param index [Integer]
+ * @return [Object,nil]
  */
 static VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -262,11 +271,14 @@ static VALUE RepeatedField_index(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.[]=(index, value)
+ * ruby-doc: RepeatedField#[]=
  *
  * Sets the element at the given index. On out-of-bounds assignments, extends
  * the array and fills the hole (if any) with default values.
+ *
+ * @param index [Integer]
+ * @param value [Object
+ * @return [nil]
  */
 static VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -296,10 +308,12 @@ static VALUE RepeatedField_index_set(VALUE _self, VALUE _index, VALUE val) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.push(value, ...)
+ * ruby-doc: RepeatedField#push
  *
  * Adds a new element to the repeated field.
+ *
+ * @param value [Object]
+ * @return [self]
  */
 static VALUE RepeatedField_push_vararg(int argc, VALUE* argv, VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -317,10 +331,12 @@ static VALUE RepeatedField_push_vararg(int argc, VALUE* argv, VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.<<(value)
+ * ruby-doc: RepeatedField#<<
  *
  * Adds a new element to the repeated field.
+ *
+ * @param value [Object]
+ * @return [self]
  */
 static VALUE RepeatedField_push(VALUE _self, VALUE val) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -355,10 +371,12 @@ static VALUE RepeatedField_pop_one(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.replace(list)
+ * ruby-doc: RepeatedField#replace
  *
  * Replaces the contents of the repeated field with the given list of elements.
+ *
+ * @param list [Array]
+ * @return [Array]
  */
 static VALUE RepeatedField_replace(VALUE _self, VALUE list) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -376,10 +394,11 @@ static VALUE RepeatedField_replace(VALUE _self, VALUE list) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.clear
+ * ruby-doc: RepeatedField#clear
  *
  * Clears (removes all elements from) this repeated field.
+ *
+ * @return [self]
  */
 static VALUE RepeatedField_clear(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -389,10 +408,11 @@ static VALUE RepeatedField_clear(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.length
+ * ruby-doc: RepeatedField#length
  *
  * Returns the length of this repeated field.
+ *
+ * @return [Integer]
  */
 static VALUE RepeatedField_length(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -400,11 +420,12 @@ static VALUE RepeatedField_length(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.dup => repeated_field
+ * ruby-doc: RepeatedField#dup
  *
  * Duplicates this repeated field with a shallow copy. References to all
  * non-primitive element objects (e.g., submessages) are shared.
+ *
+ * @return [RepeatedField]
  */
 static VALUE RepeatedField_dup(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -426,11 +447,12 @@ static VALUE RepeatedField_dup(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.to_ary => array
+ * ruby-doc: RepeatedField#to_ary
  *
  * Used when converted implicitly into array, e.g. compared to an Array.
  * Also called as a fallback of Object#to_a
+ *
+ * @return [Array]
  */
 VALUE RepeatedField_to_ary(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -448,8 +470,7 @@ VALUE RepeatedField_to_ary(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.==(other) => boolean
+ * ruby-doc: RepeatedField#==
  *
  * Compares this repeated field to another. Repeated fields are equal if their
  * element types are equal, their lengths are equal, and each element is equal.
@@ -459,6 +480,9 @@ VALUE RepeatedField_to_ary(VALUE _self) {
  * Repeated fields with dissimilar element types are never equal, even if value
  * comparison (for example, between integers and floats) would have otherwise
  * indicated that every element has equal value.
+ *
+ * @param other [RepeatedField]
+ * @return [Boolean]
  */
 VALUE RepeatedField_eq(VALUE _self, VALUE _other) {
   RepeatedField* self;
@@ -495,12 +519,13 @@ VALUE RepeatedField_eq(VALUE _self, VALUE _other) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.frozen? => bool
+ * ruby-doc: RepeatedField#frozen?
  *
  * Returns true if the repeated field is frozen in either Ruby or the underlying
  * representation. Freezes the Ruby repeated field object if it is not already
  * frozen in Ruby but it is frozen in the underlying representation.
+ *
+ * @return [Boolean]
  */
 VALUE RepeatedField_frozen(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -515,11 +540,12 @@ VALUE RepeatedField_frozen(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.freeze => self
+ * ruby-doc: RepeatedField#freeze
  *
  * Freezes the repeated field object. We have to intercept this so we can freeze
  * the underlying representation, not just the Ruby wrapper.
+ *
+ * @return [self]
  */
 VALUE RepeatedField_freeze(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -541,10 +567,11 @@ VALUE RepeatedField_freeze(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.hash => hash_value
+ * ruby-doc: RepeatedField#hash
  *
  * Returns a hash value computed from this repeated field's elements.
+ *
+ * @return [Integer]
  */
 VALUE RepeatedField_hash(VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);
@@ -560,12 +587,14 @@ VALUE RepeatedField_hash(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.+(other) => repeated field
+ * ruby-doc: RepeatedField#+
  *
  * Returns a new repeated field that contains the concatenated list of this
  * repeated field's elements and other's elements. The other (second) list may
  * be either another repeated field or a Ruby array.
+ *
+ * @param other [Array,RepeatedField]
+ * @return [RepeatedField]
  */
 VALUE RepeatedField_plus(VALUE _self, VALUE list) {
   VALUE dupped_ = RepeatedField_dup(_self);
@@ -605,10 +634,12 @@ VALUE RepeatedField_plus(VALUE _self, VALUE list) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.concat(other) => self
+ * ruby-doc: RepeatedField#concat
  *
  * concats the passed in array to self.  Returns a Ruby array.
+ *
+ * @param other [RepeatedField]
+ * @return [Array]
  */
 VALUE RepeatedField_concat(VALUE _self, VALUE list) {
   int i;
@@ -621,15 +652,21 @@ VALUE RepeatedField_concat(VALUE _self, VALUE list) {
 }
 
 /*
- * call-seq:
- *     RepeatedField.new(type, type_class = nil, initial_elems = [])
+ * ruby-doc: RepeatedField#initialize
  *
  * Creates a new repeated field. The provided type must be a Ruby symbol, and
- * can take on the same values as those accepted by FieldDescriptor#type=. If
+ * can take on the same values as those accepted by {FieldDescriptor#type=}. If
  * the type is :message or :enum, type_class must be non-nil, and must be the
- * Ruby class or module returned by Descriptor#msgclass or
- * EnumDescriptor#enummodule, respectively. An initial list of elements may also
- * be provided.
+ * Ruby class or module returned by {Descriptor#msgclass} or
+ * {EnumDescriptor#enummodule}, respectively. An initial list of elements may
+ * also be provided.
+ *
+ * @param type [Symbol]
+ * @param type_class [Class<AbstractMessage>, Module]
+ * @paramdefault type_class nil
+ * @param initial_elems [Array]
+ * @paramdefault initial_elems []
+ * @return [RepeatedField]
  */
 VALUE RepeatedField_init(int argc, VALUE* argv, VALUE _self) {
   RepeatedField* self = ruby_to_RepeatedField(_self);