google-protobuf 3.25.8 → 4.32.1

data/ext/google/protobuf_c/message.c

@@ -44,9 +44,11 @@ static void Message_mark(void* _self) {
   rb_gc_mark(self->arena);
 }
 
+static size_t Message_memsize(const void* _self) { return sizeof(Message); }
+
 static rb_data_type_t Message_type = {
     "Google::Protobuf::Message",
-    {Message_mark, RUBY_DEFAULT_FREE, NULL},
+    {Message_mark, RUBY_DEFAULT_FREE, Message_memsize},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
@@ -78,11 +80,13 @@ const upb_Message* Message_Get(VALUE msg_rb, const upb_MessageDef** m) {
 }
 
 upb_Message* Message_GetMutable(VALUE msg_rb, const upb_MessageDef** m) {
-  rb_check_frozen(msg_rb);
-  return (upb_Message*)Message_Get(msg_rb, m);
+  const upb_Message* upb_msg = Message_Get(msg_rb, m);
+  Protobuf_CheckNotFrozen(msg_rb, upb_Message_IsFrozen(upb_msg));
+  return (upb_Message*)upb_msg;
 }
 
-void Message_InitPtr(VALUE self_, upb_Message* msg, VALUE arena) {
+void Message_InitPtr(VALUE self_, const upb_Message* msg, VALUE arena) {
+  PBRUBY_ASSERT(arena != Qnil);
   Message* self = ruby_to_Message(self_);
   self->msg = msg;
   RB_OBJ_WRITE(self_, &self->arena, arena);
@@ -103,7 +107,7 @@ void Message_CheckClass(VALUE klass) {
   }
 }
 
-VALUE Message_GetRubyWrapper(upb_Message* msg, const upb_MessageDef* m,
+VALUE Message_GetRubyWrapper(const upb_Message* msg, const upb_MessageDef* m,
                              VALUE arena) {
   if (msg == NULL) return Qnil;
 
@@ -114,7 +118,6 @@ VALUE Message_GetRubyWrapper(upb_Message* msg, const upb_MessageDef* m,
     val = Message_alloc(klass);
     Message_InitPtr(val, msg, arena);
   }
-
   return val;
 }
 
@@ -246,7 +249,7 @@ static int extract_method_call(VALUE method_name, Message* self,
 static VALUE Message_oneof_accessor(VALUE _self, const upb_OneofDef* o,
                                     int accessor_type) {
   Message* self = ruby_to_Message(_self);
-  const upb_FieldDef* oneof_field = upb_Message_WhichOneof(self->msg, o);
+  const upb_FieldDef* oneof_field = upb_Message_WhichOneofByDef(self->msg, o);
 
   switch (accessor_type) {
     case METHOD_PRESENCE:
@@ -286,13 +289,42 @@ static void Message_setfield(upb_Message* msg, const upb_FieldDef* f, VALUE val,
   upb_Message_SetFieldByDef(msg, f, msgval, arena);
 }
 
+VALUE Message_getfield_frozen(const upb_Message* msg, const upb_FieldDef* f,
+                              VALUE arena) {
+  upb_MessageValue msgval = upb_Message_GetFieldByDef(msg, f);
+  if (upb_FieldDef_IsMap(f)) {
+    if (msgval.map_val == NULL) {
+      return Map_EmptyFrozen(f);
+    }
+    const upb_FieldDef* key_f = map_field_key(f);
+    const upb_FieldDef* val_f = map_field_value(f);
+    upb_CType key_type = upb_FieldDef_CType(key_f);
+    TypeInfo value_type_info = TypeInfo_get(val_f);
+    return Map_GetRubyWrapper(msgval.map_val, key_type, value_type_info, arena);
+  }
+  if (upb_FieldDef_IsRepeated(f)) {
+    if (msgval.array_val == NULL) {
+      return RepeatedField_EmptyFrozen(f);
+    }
+    return RepeatedField_GetRubyWrapper(msgval.array_val, TypeInfo_get(f),
+                                        arena);
+  }
+  VALUE ret;
+  if (upb_FieldDef_IsSubMessage(f)) {
+    const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
+    ret = Message_GetRubyWrapper(msgval.msg_val, m, arena);
+  } else {
+    ret = Convert_UpbToRuby(msgval, TypeInfo_get(f), Qnil);
+  }
+  return ret;
+}
+
 VALUE Message_getfield(VALUE _self, const upb_FieldDef* f) {
   Message* self = ruby_to_Message(_self);
-  // This is a special-case: upb_Message_Mutable() for map & array are logically
-  // const (they will not change what is serialized) but physically
-  // non-const, as they do allocate a repeated field or map. The logical
-  // constness means it's ok to do even if the message is frozen.
-  upb_Message* msg = (upb_Message*)self->msg;
+  if (upb_Message_IsFrozen(self->msg)) {
+    return Message_getfield_frozen(self->msg, f, self->arena);
+  }
+  upb_Message* msg = Message_GetMutable(_self, NULL);
   upb_Arena* arena = Arena_get(self->arena);
   if (upb_FieldDef_IsMap(f)) {
     upb_Map* map = upb_Message_Mutable(msg, f, arena).map;
@@ -305,12 +337,12 @@ VALUE Message_getfield(VALUE _self, const upb_FieldDef* f) {
     upb_Array* arr = upb_Message_Mutable(msg, f, arena).array;
     return RepeatedField_GetRubyWrapper(arr, TypeInfo_get(f), self->arena);
   } else if (upb_FieldDef_IsSubMessage(f)) {
-    if (!upb_Message_HasFieldByDef(self->msg, f)) return Qnil;
+    if (!upb_Message_HasFieldByDef(msg, f)) return Qnil;
     upb_Message* submsg = upb_Message_Mutable(msg, f, arena).msg;
     const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f);
     return Message_GetRubyWrapper(submsg, m, self->arena);
   } else {
-    upb_MessageValue msgval = upb_Message_GetFieldByDef(self->msg, f);
+    upb_MessageValue msgval = upb_Message_GetFieldByDef(msg, f);
     return Convert_UpbToRuby(msgval, TypeInfo_get(f), self->arena);
   }
 }
@@ -330,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)) {
@@ -365,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);
@@ -387,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
@@ -434,7 +466,6 @@ static VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self) {
       if (argc != 2) {
         rb_raise(rb_eArgError, "Expected 2 arguments, received %d", argc);
       }
-      rb_check_frozen(_self);
       break;
     default:
       if (argc != 1) {
@@ -560,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)) {
@@ -621,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);
@@ -652,46 +679,32 @@ 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);
   VALUE new_msg = rb_class_new_instance(0, NULL, CLASS_OF(_self));
   Message* new_msg_self = ruby_to_Message(new_msg);
-  size_t size = upb_MessageDef_MiniTable(self->msgdef)->size;
-
-  // TODO
-  // TODO
-  memcpy((upb_Message*)new_msg_self->msg, self->msg, size);
+  const upb_MiniTable* m = upb_MessageDef_MiniTable(self->msgdef);
+  upb_Message_ShallowCopy((upb_Message*)new_msg_self->msg, self->msg, m);
   Arena_fuse(self->arena, Arena_get(new_msg_self->arena));
   return new_msg;
 }
 
-// Support function for Message_eq, and also used by other #eq functions.
-bool Message_Equal(const upb_Message* m1, const upb_Message* m2,
-                   const upb_MessageDef* m) {
-  upb_Status status;
-  upb_Status_Clear(&status);
-  bool return_value = shared_Message_Equal(m1, m2, m, &status);
-  if (upb_Status_IsOk(&status)) {
-    return return_value;
-  } else {
-    rb_raise(cParseError, "Message_Equal(): %s",
-             upb_Status_ErrorMessage(&status));
-  }
-}
-
 /*
- * 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;
@@ -700,7 +713,10 @@ static VALUE Message_eq(VALUE _self, VALUE _other) {
   Message* other = ruby_to_Message(_other);
   assert(self->msgdef == other->msgdef);
 
-  return Message_Equal(self->msg, other->msg, self->msgdef) ? Qtrue : Qfalse;
+  const upb_MiniTable* m = upb_MessageDef_MiniTable(self->msgdef);
+  const int options = 0;
+  return upb_Message_IsEqual(self->msg, other->msg, m, options) ? Qtrue
+                                                                : Qfalse;
 }
 
 uint64_t Message_Hash(const upb_Message* msg, const upb_MessageDef* m,
@@ -717,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);
@@ -731,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);
@@ -769,58 +787,34 @@ static VALUE Message_CreateHash(const upb_Message* msg,
   if (!msg) return Qnil;
 
   VALUE hash = rb_hash_new();
-  int n = upb_MessageDef_FieldCount(m);
-  bool is_proto2;
-
-  // We currently have a few behaviors that are specific to proto2.
-  // This is unfortunate, we should key behaviors off field attributes (like
-  // whether a field has presence), not proto2 vs. proto3. We should see if we
-  // can change this without breaking users.
-  is_proto2 = upb_MessageDef_Syntax(m) == kUpb_Syntax_Proto2;
-
-  for (int i = 0; i < n; i++) {
-    const upb_FieldDef* field = upb_MessageDef_Field(m, i);
-    TypeInfo type_info = TypeInfo_get(field);
-    upb_MessageValue msgval;
-    VALUE msg_value;
-    VALUE msg_key;
-
-    if (!is_proto2 && upb_FieldDef_IsSubMessage(field) &&
-        !upb_FieldDef_IsRepeated(field) &&
-        !upb_Message_HasFieldByDef(msg, field)) {
-      // TODO: Legacy behavior, remove when we fix the is_proto2 differences.
-      msg_key = ID2SYM(rb_intern(upb_FieldDef_Name(field)));
-      rb_hash_aset(hash, msg_key, Qnil);
-      continue;
-    }
+  size_t iter = kUpb_Message_Begin;
+  const upb_DefPool* pool = upb_FileDef_Pool(upb_MessageDef_File(m));
+  const upb_FieldDef* field;
+  upb_MessageValue val;
 
-    // Do not include fields that are not present (oneof or optional fields).
-    if (is_proto2 && upb_FieldDef_HasPresence(field) &&
-        !upb_Message_HasFieldByDef(msg, field)) {
+  while (upb_Message_Next(msg, m, pool, &field, &val, &iter)) {
+    if (upb_FieldDef_IsExtension(field)) {
+      // TODO: allow extensions once we have decided what naming scheme the
+      // symbol should use.  eg. :"[pkg.ext]"
       continue;
     }
 
-    msg_key = ID2SYM(rb_intern(upb_FieldDef_Name(field)));
-    msgval = upb_Message_GetFieldByDef(msg, field);
-
-    // Proto2 omits empty map/repeated filds also.
+    TypeInfo type_info = TypeInfo_get(field);
+    VALUE msg_value;
 
     if (upb_FieldDef_IsMap(field)) {
       const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(field);
       const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry_m, 1);
       const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry_m, 2);
       upb_CType key_type = upb_FieldDef_CType(key_f);
-      msg_value = Map_CreateHash(msgval.map_val, key_type, TypeInfo_get(val_f));
+      msg_value = Map_CreateHash(val.map_val, key_type, TypeInfo_get(val_f));
     } else if (upb_FieldDef_IsRepeated(field)) {
-      if (is_proto2 &&
-          (!msgval.array_val || upb_Array_Size(msgval.array_val) == 0)) {
-        continue;
-      }
-      msg_value = RepeatedField_CreateArray(msgval.array_val, type_info);
+      msg_value = RepeatedField_CreateArray(val.array_val, type_info);
     } else {
-      msg_value = Scalar_CreateHash(msgval, type_info);
+      msg_value = Scalar_CreateHash(val, type_info);
     }
 
+    VALUE msg_key = ID2SYM(rb_intern(upb_FieldDef_Name(field)));
     rb_hash_aset(hash, msg_key, msg_value);
   }
 
@@ -836,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);
@@ -847,53 +842,56 @@ static VALUE Message_to_h(VALUE _self) {
 }
 
 /*
- * call-seq:
- *     Message.freeze => self
+ * ruby-doc: AbstractMessage#frozen?
  *
- * Freezes the message object. We have to intercept this so we can pin the
- * Ruby object into memory so we don't forget it's 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]
  */
-static VALUE Message_freeze(VALUE _self) {
+VALUE Message_frozen(VALUE _self) {
   Message* self = ruby_to_Message(_self);
-  if (!RB_OBJ_FROZEN(_self)) {
-    Arena_Pin(self->arena, _self);
-    RB_OBJ_FREEZE(_self);
+  if (!upb_Message_IsFrozen(self->msg)) {
+    PBRUBY_ASSERT(!RB_OBJ_FROZEN(_self));
+    return Qfalse;
   }
-  return _self;
+
+  // Lazily freeze the Ruby wrapper.
+  if (!RB_OBJ_FROZEN(_self)) RB_OBJ_FREEZE(_self);
+  return Qtrue;
 }
 
 /*
- * Deep freezes the message object recursively.
- * Internal use only.
+ * 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_internal_deep_freeze(VALUE _self) {
+VALUE Message_freeze(VALUE _self) {
   Message* self = ruby_to_Message(_self);
-  Message_freeze(_self);
-
-  int n = upb_MessageDef_FieldCount(self->msgdef);
-  for (int i = 0; i < n; i++) {
-    const upb_FieldDef* f = upb_MessageDef_Field(self->msgdef, i);
-    VALUE field = Message_getfield(_self, f);
-
-    if (field != Qnil) {
-      if (upb_FieldDef_IsMap(f)) {
-        Map_internal_deep_freeze(field);
-      } else if (upb_FieldDef_IsRepeated(f)) {
-        RepeatedField_internal_deep_freeze(field);
-      } else if (upb_FieldDef_IsSubMessage(f)) {
-        Message_internal_deep_freeze(field);
-      }
-    }
+  if (RB_OBJ_FROZEN(_self)) {
+    PBRUBY_ASSERT(upb_Message_IsFrozen(self->msg));
+    return _self;
+  }
+  if (!upb_Message_IsFrozen(self->msg)) {
+    upb_Message_Freeze(Message_GetMutable(_self, NULL),
+                       upb_MessageDef_MiniTable(self->msgdef));
   }
+  RB_OBJ_FREEZE(_self);
   return _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);
@@ -910,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);
@@ -936,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];
@@ -990,31 +993,29 @@ VALUE Message_decode_bytes(int size, const char* bytes, int options,
     rb_raise(cParseError, "Error occurred during parsing");
   }
   if (freeze) {
-    Message_internal_deep_freeze(msg_rb);
+    Message_freeze(msg_rb);
   }
   return msg_rb;
 }
 
 /*
- * 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];
   int options = 0;
   upb_Status status;
 
-  // TODO: use this message's pool instead.
-  const upb_DefPool* symtab = DescriptorPool_GetSymtab(generated_pool);
-
   if (argc < 1 || argc > 2) {
     rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
   }
@@ -1048,24 +1049,35 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
   }
 
   upb_Status_Clear(&status);
-  if (!upb_JsonDecode(RSTRING_PTR(data), RSTRING_LEN(data),
-                      (upb_Message*)msg->msg, msg->msgdef, symtab, options,
-                      Arena_get(msg->arena), &status)) {
-    rb_raise(cParseError, "Error occurred during parsing: %s",
-             upb_Status_ErrorMessage(&status));
+  const upb_DefPool* pool = upb_FileDef_Pool(upb_MessageDef_File(msg->msgdef));
+
+  int result = upb_JsonDecodeDetectingNonconformance(
+      RSTRING_PTR(data), RSTRING_LEN(data), (upb_Message*)msg->msg,
+      msg->msgdef, pool, options, Arena_get(msg->arena), &status);
+
+  switch (result) {
+    case kUpb_JsonDecodeResult_Ok:
+      break;
+    case kUpb_JsonDecodeResult_Error:
+      rb_raise(cParseError, "Error occurred during parsing: %s",
+               upb_Status_ErrorMessage(&status));
+      break;
   }
 
   return msg_rb;
 }
 
 /*
- * 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]);
@@ -1128,9 +1143,6 @@ static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
   size_t size;
   upb_Status status;
 
-  // TODO: use this message's pool instead.
-  const upb_DefPool* symtab = DescriptorPool_GetSymtab(generated_pool);
-
   if (argc < 1 || argc > 2) {
     rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
   }
@@ -1165,8 +1177,9 @@ static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
   }
 
   upb_Status_Clear(&status);
-  size = upb_JsonEncode(msg->msg, msg->msgdef, symtab, options, buf,
-                        sizeof(buf), &status);
+  const upb_DefPool* pool = upb_FileDef_Pool(upb_MessageDef_File(msg->msgdef));
+  size = upb_JsonEncode(msg->msg, msg->msgdef, pool, options, buf, sizeof(buf),
+                        &status);
 
   if (!upb_Status_IsOk(&status)) {
     rb_raise(cParseError, "Error occurred during encoding: %s",
@@ -1176,7 +1189,7 @@ static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
   VALUE ret;
   if (size >= sizeof(buf)) {
     char* buf2 = malloc(size + 1);
-    upb_JsonEncode(msg->msg, msg->msgdef, symtab, options, buf2, size + 1,
+    upb_JsonEncode(msg->msg, msg->msgdef, pool, options, buf2, size + 1,
                    &status);
     ret = rb_str_new(buf2, size);
     free(buf2);
@@ -1189,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);
@@ -1216,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);
@@ -1236,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));
@@ -1255,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);
@@ -1402,6 +1434,7 @@ static void Message_define_class(VALUE klass) {
   rb_define_method(klass, "==", Message_eq, 1);
   rb_define_method(klass, "eql?", Message_eq, 1);
   rb_define_method(klass, "freeze", Message_freeze, 0);
+  rb_define_method(klass, "frozen?", Message_frozen, 0);
   rb_define_method(klass, "hash", Message_hash, 0);
   rb_define_method(klass, "to_h", Message_to_h, 0);
   rb_define_method(klass, "inspect", Message_inspect, 0);