google-protobuf 3.8.0 → 3.15.0

data/ext/google/protobuf_c/message.c

@@ -28,91 +28,154 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#include "message.h"
+
+#include "convert.h"
+#include "defs.h"
+#include "map.h"
 #include "protobuf.h"
+#include "repeated_field.h"
+#include "third_party/wyhash/wyhash.h"
 
-// -----------------------------------------------------------------------------
-// Class/module creation from msgdefs and enumdefs, respectively.
-// -----------------------------------------------------------------------------
+static VALUE cParseError = Qnil;
+static ID descriptor_instancevar_interned;
 
-void* Message_data(void* msg) {
-  return ((uint8_t *)msg) + sizeof(MessageHeader);
+static VALUE initialize_rb_class_with_no_args(VALUE klass) {
+    return rb_funcall(klass, rb_intern("new"), 0);
 }
 
-void Message_mark(void* _self) {
-  MessageHeader* self = (MessageHeader *)_self;
-  layout_mark(self->descriptor->layout, Message_data(self));
+VALUE MessageOrEnum_GetDescriptor(VALUE klass) {
+  return rb_ivar_get(klass, descriptor_instancevar_interned);
 }
 
-void Message_free(void* self) {
-  stringsink* unknown = ((MessageHeader *)self)->unknown_fields;
-  if (unknown != NULL) {
-    stringsink_uninit(unknown);
-    free(unknown);
-  }
-  xfree(self);
+// -----------------------------------------------------------------------------
+// Class/module creation from msgdefs and enumdefs, respectively.
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  VALUE arena;
+  const upb_msg* msg;        // Can get as mutable when non-frozen.
+  const upb_msgdef* msgdef;  // kept alive by self.class.descriptor reference.
+} Message;
+
+static void Message_mark(void* _self) {
+  Message* self = (Message *)_self;
+  rb_gc_mark(self->arena);
 }
 
-rb_data_type_t Message_type = {
+static rb_data_type_t Message_type = {
   "Message",
-  { Message_mark, Message_free, NULL },
+  { Message_mark, RUBY_DEFAULT_FREE, NULL },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE Message_alloc(VALUE klass) {
+static Message* ruby_to_Message(VALUE msg_rb) {
+  Message* msg;
+  TypedData_Get_Struct(msg_rb, Message, &Message_type, msg);
+  return msg;
+}
+
+static VALUE Message_alloc(VALUE klass) {
   VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
-  Descriptor* desc = ruby_to_Descriptor(descriptor);
-  MessageHeader* msg = (MessageHeader*)ALLOC_N(
-      uint8_t, sizeof(MessageHeader) + desc->layout->size);
+  Message* msg = ALLOC(Message);
   VALUE ret;
 
-  memset(Message_data(msg), 0, desc->layout->size);
+  msg->msgdef = Descriptor_GetMsgDef(descriptor);
+  msg->arena = Qnil;
+  msg->msg = NULL;
 
-  // We wrap first so that everything in the message object is GC-rooted in case
-  // a collection happens during object creation in layout_init().
   ret = TypedData_Wrap_Struct(klass, &Message_type, msg);
-  msg->descriptor = desc;
   rb_ivar_set(ret, descriptor_instancevar_interned, descriptor);
 
-  msg->unknown_fields = NULL;
+  return ret;
+}
 
-  layout_init(desc->layout, Message_data(msg));
+const upb_msg *Message_Get(VALUE msg_rb, const upb_msgdef **m) {
+  Message* msg = ruby_to_Message(msg_rb);
+  if (m) *m = msg->msgdef;
+  return msg->msg;
+}
 
-  return ret;
+upb_msg *Message_GetMutable(VALUE msg_rb, const upb_msgdef **m) {
+  rb_check_frozen(msg_rb);
+  return (upb_msg*)Message_Get(msg_rb, m);
 }
 
-static const upb_fielddef* which_oneof_field(MessageHeader* self, const upb_oneofdef* o) {
-  upb_oneof_iter it;
-  size_t case_ofs;
-  uint32_t oneof_case;
-  const upb_fielddef* first_field;
-  const upb_fielddef* f;
+void Message_InitPtr(VALUE self_, upb_msg *msg, VALUE arena) {
+  Message* self = ruby_to_Message(self_);
+  self->msg = msg;
+  self->arena = arena;
+  ObjectCache_Add(msg, self_, Arena_get(arena));
+}
 
-  // If no fields in the oneof, always nil.
-  if (upb_oneofdef_numfields(o) == 0) {
-    return NULL;
+VALUE Message_GetArena(VALUE msg_rb) {
+  Message* msg = ruby_to_Message(msg_rb);
+  return msg->arena;
+}
+
+void Message_CheckClass(VALUE klass) {
+  if (rb_get_alloc_func(klass) != &Message_alloc) {
+    rb_raise(rb_eArgError,
+             "Message class was not returned by the DescriptorPool.");
   }
-  // Grab the first field in the oneof so we can get its layout info to find the
-  // oneof_case field.
-  upb_oneof_begin(&it, o);
-  assert(!upb_oneof_done(&it));
-  first_field = upb_oneof_iter_field(&it);
-  assert(upb_fielddef_containingoneof(first_field) != NULL);
+}
 
-  case_ofs =
-      self->descriptor->layout->
-      fields[upb_fielddef_index(first_field)].case_offset;
-  oneof_case = *((uint32_t*)((char*)Message_data(self) + case_ofs));
+VALUE Message_GetRubyWrapper(upb_msg* msg, const upb_msgdef* m, VALUE arena) {
+  if (msg == NULL) return Qnil;
 
-  if (oneof_case == ONEOF_CASE_NONE) {
-    return NULL;
+  VALUE val = ObjectCache_Get(msg);
+
+  if (val == Qnil) {
+    VALUE klass = Descriptor_DefToClass(m);
+    val = Message_alloc(klass);
+    Message_InitPtr(val, msg, arena);
   }
 
-  // oneof_case is a field index, so find that field.
-  f = upb_oneofdef_itof(o, oneof_case);
-  assert(f != NULL);
+  return val;
+}
+
+void Message_PrintMessage(StringBuilder* b, const upb_msg* msg,
+                          const upb_msgdef* m) {
+  bool first = true;
+  int n = upb_msgdef_fieldcount(m);
+  VALUE klass = Descriptor_DefToClass(m);
+  StringBuilder_Printf(b, "<%s: ", rb_class2name(klass));
+
+  for (int i = 0; i < n; i++) {
+    const upb_fielddef* field = upb_msgdef_field(m, i);
+
+    if (upb_fielddef_haspresence(field) && !upb_msg_has(msg, field)) {
+      continue;
+    }
+
+    if (!first) {
+      StringBuilder_Printf(b, ", ");
+    } else {
+      first = false;
+    }
+
+    upb_msgval msgval = upb_msg_get(msg, field);
+
+    StringBuilder_Printf(b, "%s: ", upb_fielddef_name(field));
+
+    if (upb_fielddef_ismap(field)) {
+      const upb_msgdef* entry_m = upb_fielddef_msgsubdef(field);
+      const upb_fielddef* key_f = upb_msgdef_itof(entry_m, 1);
+      const upb_fielddef* val_f = upb_msgdef_itof(entry_m, 2);
+      TypeInfo val_info = TypeInfo_get(val_f);
+      Map_Inspect(b, msgval.map_val, upb_fielddef_type(key_f), val_info);
+    } else if (upb_fielddef_isseq(field)) {
+      RepeatedField_Inspect(b, msgval.array_val, TypeInfo_get(field));
+    } else {
+      StringBuilder_PrintMsgval(b, msgval, TypeInfo_get(field));
+    }
+  }
 
-  return f;
+  StringBuilder_Printf(b, ">");
 }
 
+// Helper functions for #method_missing ////////////////////////////////////////
+
 enum {
   METHOD_UNKNOWN = 0,
   METHOD_GETTER = 1,
@@ -125,133 +188,199 @@ enum {
 };
 
 // Check if the field is a well known wrapper type
-static bool is_wrapper_type_field(const upb_fielddef* field) {
-  char* field_type_name = rb_class2name(field_type_class(field));
-
-  return strcmp(field_type_name, "Google::Protobuf::DoubleValue") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::FloatValue") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::Int32Value") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::Int64Value") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::UInt32Value") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::UInt64Value") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::BoolValue") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::StringValue") == 0 ||
-         strcmp(field_type_name, "Google::Protobuf::BytesValue") == 0;
-}
-
-// Get a new Ruby wrapper type and set the initial value
-static VALUE ruby_wrapper_type(const upb_fielddef* field, const VALUE* value) {
-  if (is_wrapper_type_field(field) && value != Qnil) {
-    VALUE hash = rb_hash_new();
-    rb_hash_aset(hash, rb_str_new2("value"), value);
-    VALUE args[1] = { hash };
-    return rb_class_new_instance(1, args, field_type_class(field));
+static bool IsWrapper(const upb_fielddef* f) {
+  return upb_fielddef_issubmsg(f) &&
+         upb_msgdef_iswrapper(upb_fielddef_msgsubdef(f));
+}
+
+static bool Match(const upb_msgdef* m, const char* name, const upb_fielddef** f,
+                  const upb_oneofdef** o, const char* prefix,
+                  const char* suffix) {
+  size_t sp = strlen(prefix);
+  size_t ss = strlen(suffix);
+  size_t sn = strlen(name);
+
+  if (sn <= sp + ss) return false;
+
+  if (memcmp(name, prefix, sp) != 0 ||
+      memcmp(name + sn - ss, suffix, ss) != 0) {
+    return false;
   }
-  return Qnil;
+
+  return upb_msgdef_lookupname(m, name + sp, sn - sp - ss, f, o);
 }
 
-static int extract_method_call(VALUE method_name, MessageHeader* self,
-			       const upb_fielddef **f, const upb_oneofdef **o) {
+static int extract_method_call(VALUE method_name, Message* self,
+                               const upb_fielddef** f, const upb_oneofdef** o) {
+  const upb_msgdef* m = self->msgdef;
+  const char* name;
+
   Check_Type(method_name, T_SYMBOL);
+  name = rb_id2name(SYM2ID(method_name));
+
+  if (Match(m, name, f, o, "", "")) return METHOD_GETTER;
+  if (Match(m, name, f, o, "", "=")) return METHOD_SETTER;
+  if (Match(m, name, f, o, "clear_", "")) return METHOD_CLEAR;
+  if (Match(m, name, f, o, "has_", "?") &&
+      (*o || (*f && upb_fielddef_haspresence(*f)))) {
+    // Disallow oneof hazzers for proto3.
+    // TODO(haberman): remove this test when we are enabling oneof hazzers for
+    // proto3.
+    if (*f && !upb_fielddef_issubmsg(*f) &&
+        upb_fielddef_realcontainingoneof(*f) &&
+        upb_msgdef_syntax(upb_fielddef_containingtype(*f)) !=
+            UPB_SYNTAX_PROTO2) {
+      return METHOD_UNKNOWN;
+    }
+    return METHOD_PRESENCE;
+  }
+  if (Match(m, name, f, o, "", "_as_value") && *f && !upb_fielddef_isseq(*f) &&
+      IsWrapper(*f)) {
+    return METHOD_WRAPPER_GETTER;
+  }
+  if (Match(m, name, f, o, "", "_as_value=") && *f && !upb_fielddef_isseq(*f) &&
+      IsWrapper(*f)) {
+    return METHOD_WRAPPER_SETTER;
+  }
+  if (Match(m, name, f, o, "", "_const") && *f &&
+      upb_fielddef_type(*f) == UPB_TYPE_ENUM) {
+    return METHOD_ENUM_GETTER;
+  }
 
-  VALUE method_str = rb_id2str(SYM2ID(method_name));
-  char* name = RSTRING_PTR(method_str);
-  size_t name_len = RSTRING_LEN(method_str);
-  int accessor_type;
-  const upb_oneofdef* test_o;
-  const upb_fielddef* test_f;
-
-  if (name[name_len - 1] == '=') {
-    accessor_type = METHOD_SETTER;
-    name_len--;
-    // We want to ensure if the proto has something named clear_foo or has_foo?,
-    // we don't strip the prefix.
-  } else if (strncmp("clear_", name, 6) == 0 &&
-             !upb_msgdef_lookupname(self->descriptor->msgdef, name, name_len,
-				    &test_f, &test_o)) {
-    accessor_type = METHOD_CLEAR;
-    name = name + 6;
-    name_len = name_len - 6;
-  } else if (strncmp("has_", name, 4) == 0 && name[name_len - 1] == '?' &&
-             !upb_msgdef_lookupname(self->descriptor->msgdef, name, name_len,
-				    &test_f, &test_o)) {
-    accessor_type = METHOD_PRESENCE;
-    name = name + 4;
-    name_len = name_len - 5;
-  } else {
-    accessor_type = METHOD_GETTER;
-  }
-
-  bool has_field = upb_msgdef_lookupname(self->descriptor->msgdef, name, name_len,
-			                                   &test_f, &test_o);
-
-  // Look for wrapper type accessor of the form <field_name>_as_value
-  if (!has_field &&
-      (accessor_type == METHOD_GETTER || accessor_type == METHOD_SETTER) &&
-      name_len > 9 && strncmp(name + name_len - 9, "_as_value", 9) == 0) {
-    // Find the field name
-    char wrapper_field_name[name_len - 8];
-    strncpy(wrapper_field_name, name, name_len - 9);
-    wrapper_field_name[name_len - 7] = '\0';
-
-    // Check if field exists and is a wrapper type
-    const upb_oneofdef* test_o_wrapper;
-    const upb_fielddef* test_f_wrapper;
-    if (upb_msgdef_lookupname(self->descriptor->msgdef, wrapper_field_name, name_len - 9,
-			                        &test_f_wrapper, &test_o_wrapper) &&
-        upb_fielddef_type(test_f_wrapper) == UPB_TYPE_MESSAGE &&
-        is_wrapper_type_field(test_f_wrapper)) {
-      // It does exist!
-      has_field = true;
-      if (accessor_type == METHOD_SETTER) {
-        accessor_type = METHOD_WRAPPER_SETTER;
-      } else {
-        accessor_type = METHOD_WRAPPER_GETTER;
+  return METHOD_UNKNOWN;
+}
+
+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_msg_whichoneof(self->msg, o);
+
+  switch (accessor_type) {
+    case METHOD_PRESENCE:
+      return oneof_field == NULL ? Qfalse : Qtrue;
+    case METHOD_CLEAR:
+      if (oneof_field != NULL) {
+        upb_msg_clearfield(Message_GetMutable(_self, NULL), oneof_field);
       }
-      test_o = test_o_wrapper;
-      test_f = test_f_wrapper;
-    }
+      return Qnil;
+    case METHOD_GETTER:
+      return oneof_field == NULL
+                 ? Qnil
+                 : ID2SYM(rb_intern(upb_fielddef_name(oneof_field)));
+    case METHOD_SETTER:
+      rb_raise(rb_eRuntimeError, "Oneof accessors are read-only.");
   }
+  rb_raise(rb_eRuntimeError, "Invalid access of oneof field.");
+}
 
-  // Look for enum accessor of the form <enum_name>_const
-  if (!has_field && accessor_type == METHOD_GETTER &&
-      name_len > 6 && strncmp(name + name_len - 6, "_const", 6) == 0) {
-
-    // Find enum field name
-    char enum_name[name_len - 5];
-    strncpy(enum_name, name, name_len - 6);
-    enum_name[name_len - 4] = '\0';
-
-    // Check if enum field exists
-    const upb_oneofdef* test_o_enum;
-    const upb_fielddef* test_f_enum;
-    if (upb_msgdef_lookupname(self->descriptor->msgdef, enum_name, name_len - 6,
-			                        &test_f_enum, &test_o_enum) &&
-        upb_fielddef_type(test_f_enum) == UPB_TYPE_ENUM) {
-      // It does exist!
-      has_field = true;
-      accessor_type = METHOD_ENUM_GETTER;
-      test_o = test_o_enum;
-      test_f = test_f_enum;
+static void Message_setfield(upb_msg* msg, const upb_fielddef* f, VALUE val,
+                             upb_arena* arena) {
+  upb_msgval msgval;
+  if (upb_fielddef_ismap(f)) {
+    msgval.map_val = Map_GetUpbMap(val, f);
+  } else if (upb_fielddef_isseq(f)) {
+    msgval.array_val = RepeatedField_GetUpbArray(val, f);
+  } else {
+    if (val == Qnil &&
+        (upb_fielddef_issubmsg(f) || upb_fielddef_realcontainingoneof(f))) {
+      upb_msg_clearfield(msg, f);
+      return;
     }
+    msgval =
+        Convert_RubyToUpb(val, upb_fielddef_name(f), TypeInfo_get(f), arena);
   }
+  upb_msg_set(msg, f, msgval, arena);
+}
 
-  // Verify the name corresponds to a oneof or field in this message.
-  if (!has_field) {
-    return METHOD_UNKNOWN;
-  }
+static VALUE Message_field_accessor(VALUE _self, const upb_fielddef* f,
+                                    int accessor_type, int argc, VALUE* argv) {
+  upb_arena *arena = Arena_get(Message_GetArena(_self));
 
-  // Method calls like 'has_foo?' are not allowed if field "foo" does not have
-  // a hasbit (e.g. repeated fields or non-message type fields for proto3
-  // syntax).
-  if (accessor_type == METHOD_PRESENCE && test_f != NULL &&
-      !upb_fielddef_haspresence(test_f)) {
-    return METHOD_UNKNOWN;
+  switch (accessor_type) {
+    case METHOD_SETTER:
+      Message_setfield(Message_GetMutable(_self, NULL), f, argv[1], arena);
+      return Qnil;
+    case METHOD_CLEAR:
+      upb_msg_clearfield(Message_GetMutable(_self, NULL), f);
+      return Qnil;
+    case METHOD_PRESENCE:
+      if (!upb_fielddef_haspresence(f)) {
+        rb_raise(rb_eRuntimeError, "Field does not have presence.");
+      }
+      return upb_msg_has(Message_Get(_self, NULL), f);
+    case METHOD_WRAPPER_GETTER: {
+      Message* self = ruby_to_Message(_self);
+      if (upb_msg_has(self->msg, f)) {
+        PBRUBY_ASSERT(upb_fielddef_issubmsg(f) && !upb_fielddef_isseq(f));
+        upb_msgval wrapper = upb_msg_get(self->msg, f);
+        const upb_msgdef *wrapper_m = upb_fielddef_msgsubdef(f);
+        const upb_fielddef *value_f = upb_msgdef_itof(wrapper_m, 1);
+        upb_msgval value = upb_msg_get(wrapper.msg_val, value_f);
+        return Convert_UpbToRuby(value, TypeInfo_get(value_f), self->arena);
+      } else {
+        return Qnil;
+      }
+    }
+    case METHOD_WRAPPER_SETTER: {
+      upb_msg *msg = Message_GetMutable(_self, NULL);
+      if (argv[1] == Qnil) {
+        upb_msg_clearfield(msg, f);
+      } else {
+        const upb_fielddef *val_f = upb_msgdef_itof(upb_fielddef_msgsubdef(f), 1);
+        upb_msgval msgval = Convert_RubyToUpb(argv[1], upb_fielddef_name(f),
+                                              TypeInfo_get(val_f), arena);
+        upb_msg *wrapper = upb_msg_mutable(msg, f, arena).msg;
+        upb_msg_set(wrapper, val_f, msgval, arena);
+      }
+      return Qnil;
+    }
+    case METHOD_ENUM_GETTER: {
+      upb_msgval msgval = upb_msg_get(Message_Get(_self, NULL), f);
+
+      if (upb_fielddef_label(f) == UPB_LABEL_REPEATED) {
+        // Map repeated fields to a new type with ints
+        VALUE arr = rb_ary_new();
+        size_t i, n = upb_array_size(msgval.array_val);
+        for (i = 0; i < n; i++) {
+          upb_msgval elem = upb_array_get(msgval.array_val, i);
+          rb_ary_push(arr, INT2NUM(elem.int32_val));
+        }
+        return arr;
+      } else {
+        return INT2NUM(msgval.int32_val);
+      }
+    }
+    case METHOD_GETTER: {
+      Message* self = ruby_to_Message(_self);
+      // This is a special-case: upb_msg_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_msg *msg = (upb_msg*)self->msg;
+      if (upb_fielddef_ismap(f)) {
+        upb_map *map = upb_msg_mutable(msg, f, arena).map;
+        const upb_fielddef *key_f = map_field_key(f);
+        const upb_fielddef *val_f = map_field_value(f);
+        upb_fieldtype_t key_type = upb_fielddef_type(key_f);
+        TypeInfo value_type_info = TypeInfo_get(val_f);
+        return Map_GetRubyWrapper(map, key_type, value_type_info, self->arena);
+      } else if (upb_fielddef_isseq(f)) {
+        upb_array *arr = upb_msg_mutable(msg, f, arena).array;
+        return RepeatedField_GetRubyWrapper(arr, TypeInfo_get(f), self->arena);
+      } else if (upb_fielddef_issubmsg(f)) {
+        if (!upb_msg_has(self->msg, f)) return Qnil;
+        upb_msg *submsg = upb_msg_mutable(msg, f, arena).msg;
+        const upb_msgdef *m = upb_fielddef_msgsubdef(f);
+        return Message_GetRubyWrapper(submsg, m, self->arena);
+      } else {
+        upb_msgval msgval = upb_msg_get(self->msg, f);
+        return Convert_UpbToRuby(msgval, TypeInfo_get(f), self->arena);
+      }
+    default:
+      rb_raise(rb_eRuntimeError, "Internal error, no such accessor: %d",
+               accessor_type);
+    }
   }
-
-  *o = test_o;
-  *f = test_f;
-  return accessor_type;
 }
 
 /*
@@ -281,102 +410,56 @@ static int extract_method_call(VALUE method_name, MessageHeader* self,
  * true if the field 'fieldname' is set in the message object, else false. For
  * 'proto3' syntax, calling this for a basic type field will result in an error.
  */
-VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self) {
-  MessageHeader* self;
+static VALUE Message_method_missing(int argc, VALUE* argv, VALUE _self) {
+  Message* self = ruby_to_Message(_self);
   const upb_oneofdef* o;
   const upb_fielddef* f;
+  int accessor_type;
 
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
   if (argc < 1) {
     rb_raise(rb_eArgError, "Expected method name as first argument.");
   }
 
-  int accessor_type = extract_method_call(argv[0], self, &f, &o);
-  if (accessor_type == METHOD_UNKNOWN || (o == NULL && f == NULL) ) {
-    return rb_call_super(argc, argv);
-  } else if (accessor_type == METHOD_SETTER || accessor_type == METHOD_WRAPPER_SETTER) {
-    if (argc != 2) {
-      rb_raise(rb_eArgError, "Expected 2 arguments, received %d", argc);
-    }
-    rb_check_frozen(_self);
-  } else if (argc != 1) {
-    rb_raise(rb_eArgError, "Expected 1 argument, received %d", argc);
-  }
+  accessor_type = extract_method_call(argv[0], self, &f, &o);
 
-  // Return which of the oneof fields are set
-  if (o != NULL) {
-    if (accessor_type == METHOD_SETTER) {
-      rb_raise(rb_eRuntimeError, "Oneof accessors are read-only.");
-    }
+  if (accessor_type == METHOD_UNKNOWN) return rb_call_super(argc, argv);
 
-    const upb_fielddef* oneof_field = which_oneof_field(self, o);
-    if (accessor_type == METHOD_PRESENCE) {
-      return oneof_field == NULL ? Qfalse : Qtrue;
-    } else if (accessor_type == METHOD_CLEAR) {
-      if (oneof_field != NULL) {
-        layout_clear(self->descriptor->layout, Message_data(self), oneof_field);
+  // Validate argument count.
+  switch (accessor_type) {
+    case METHOD_SETTER:
+    case METHOD_WRAPPER_SETTER:
+      if (argc != 2) {
+        rb_raise(rb_eArgError, "Expected 2 arguments, received %d", argc);
       }
-      return Qnil;
-    } else {
-      // METHOD_ACCESSOR
-      return oneof_field == NULL ? Qnil :
-        ID2SYM(rb_intern(upb_fielddef_name(oneof_field)));
-    }
-  // Otherwise we're operating on a single proto field
-  } else if (accessor_type == METHOD_SETTER) {
-    layout_set(self->descriptor->layout, Message_data(self), f, argv[1]);
-    return Qnil;
-  } else if (accessor_type == METHOD_CLEAR) {
-    layout_clear(self->descriptor->layout, Message_data(self), f);
-    return Qnil;
-  } else if (accessor_type == METHOD_PRESENCE) {
-    return layout_has(self->descriptor->layout, Message_data(self), f);
-  } else if (accessor_type == METHOD_WRAPPER_GETTER) {
-    VALUE value = layout_get(self->descriptor->layout, Message_data(self), f);
-    if (value != Qnil) {
-      value = rb_funcall(value, rb_intern("value"), 0);
-    }
-    return value;
-  } else if (accessor_type == METHOD_WRAPPER_SETTER) {
-    VALUE wrapper = ruby_wrapper_type(f, argv[1]);
-    layout_set(self->descriptor->layout, Message_data(self), f, wrapper);
-    return Qnil;
-  } else if (accessor_type == METHOD_ENUM_GETTER) {
-    VALUE enum_type = field_type_class(f);
-    VALUE method = rb_intern("const_get");
-    VALUE raw_value = layout_get(self->descriptor->layout, Message_data(self), f);
-
-    // Map repeated fields to a new type with ints
-    if (upb_fielddef_label(f) == UPB_LABEL_REPEATED) {
-      int array_size = FIX2INT(rb_funcall(raw_value, rb_intern("length"), 0));
-      VALUE array_args[1] = { ID2SYM(rb_intern("int64")) };
-      VALUE array = rb_class_new_instance(1, array_args, CLASS_OF(raw_value));
-      for (int i = 0; i < array_size; i++) {
-        VALUE entry = rb_funcall(enum_type, method, 1, rb_funcall(raw_value,
-                                 rb_intern("at"), 1, INT2NUM(i)));
-        rb_funcall(array, rb_intern("push"), 1, entry);
+      rb_check_frozen(_self);
+      break;
+    default:
+      if (argc != 1) {
+        rb_raise(rb_eArgError, "Expected 1 argument, received %d", argc);
       }
-      return array;
-    }
-    // Convert the value for singular fields
-    return rb_funcall(enum_type, method, 1, raw_value);
+      break;
+  }
+
+  // Dispatch accessor.
+  if (o != NULL) {
+    return Message_oneof_accessor(_self, o, accessor_type);
   } else {
-    return layout_get(self->descriptor->layout, Message_data(self), f);
+    return Message_field_accessor(_self, f, accessor_type, argc, argv);
   }
 }
 
-
-VALUE Message_respond_to_missing(int argc, VALUE* argv, VALUE _self) {
-  MessageHeader* self;
+static VALUE Message_respond_to_missing(int argc, VALUE* argv, VALUE _self) {
+  Message* self = ruby_to_Message(_self);
   const upb_oneofdef* o;
   const upb_fielddef* f;
+  int accessor_type;
 
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
   if (argc < 1) {
     rb_raise(rb_eArgError, "Expected method name as first argument.");
   }
 
-  int accessor_type = extract_method_call(argv[0], self, &f, &o);
+  accessor_type = extract_method_call(argv[0], self, &f, &o);
+
   if (accessor_type == METHOD_UNKNOWN) {
     return rb_call_super(argc, argv);
   } else if (o != NULL) {
@@ -386,22 +469,116 @@ VALUE Message_respond_to_missing(int argc, VALUE* argv, VALUE _self) {
   }
 }
 
-VALUE create_submsg_from_hash(const upb_fielddef *f, VALUE hash) {
-  const upb_def *d = upb_fielddef_subdef(f);
-  assert(d != NULL);
+void Message_InitFromValue(upb_msg* msg, const upb_msgdef* m, VALUE val,
+                           upb_arena* arena);
+
+typedef struct {
+  upb_map *map;
+  TypeInfo key_type;
+  TypeInfo val_type;
+  upb_arena *arena;
+} MapInit;
+
+static int Map_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
+  MapInit *map_init = (MapInit*)_self;
+  upb_msgval k, v;
+  k = Convert_RubyToUpb(key, "", map_init->key_type, NULL);
+
+  if (map_init->val_type.type == UPB_TYPE_MESSAGE && TYPE(val) == T_HASH) {
+    upb_msg *msg = upb_msg_new(map_init->val_type.def.msgdef, map_init->arena);
+    Message_InitFromValue(msg, map_init->val_type.def.msgdef, val,
+                          map_init->arena);
+    v.msg_val = msg;
+  } else {
+    v = Convert_RubyToUpb(val, "", map_init->val_type, map_init->arena);
+  }
+  upb_map_set(map_init->map, k, v, map_init->arena);
+  return ST_CONTINUE;
+}
 
-  VALUE descriptor = get_def_obj(d);
-  VALUE msgclass = rb_funcall(descriptor, rb_intern("msgclass"), 0, NULL);
+static void Map_InitFromValue(upb_map* map, const upb_fielddef* f, VALUE val,
+                       upb_arena* arena) {
+  const upb_msgdef* entry_m = upb_fielddef_msgsubdef(f);
+  const upb_fielddef* key_f = upb_msgdef_itof(entry_m, 1);
+  const upb_fielddef* val_f = upb_msgdef_itof(entry_m, 2);
+  if (TYPE(val) != T_HASH) {
+    rb_raise(rb_eArgError,
+             "Expected Hash object as initializer value for map field '%s' "
+             "(given %s).",
+             upb_fielddef_name(f), rb_class2name(CLASS_OF(val)));
+  }
+  MapInit map_init = {map, TypeInfo_get(key_f), TypeInfo_get(val_f), arena};
+  rb_hash_foreach(val, Map_initialize_kwarg, (VALUE)&map_init);
+}
 
-  VALUE args[1] = { hash };
-  return rb_class_new_instance(1, args, msgclass);
+static upb_msgval MessageValue_FromValue(VALUE val, TypeInfo info,
+                                         upb_arena* arena) {
+  if (info.type == UPB_TYPE_MESSAGE) {
+    upb_msgval msgval;
+    upb_msg* msg = upb_msg_new(info.def.msgdef, arena);
+    Message_InitFromValue(msg, info.def.msgdef, val, arena);
+    msgval.msg_val = msg;
+    return msgval;
+  } else {
+    return Convert_RubyToUpb(val, "", info, arena);
+  }
 }
 
-int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
-  MessageHeader* self;
-  char *name;
-  const upb_fielddef* f;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
+static void RepeatedField_InitFromValue(upb_array* arr, const upb_fielddef* f,
+                                        VALUE val, upb_arena* arena) {
+  TypeInfo type_info = TypeInfo_get(f);
+
+  if (TYPE(val) != T_ARRAY) {
+    rb_raise(rb_eArgError,
+             "Expected array as initializer value for repeated field '%s' (given %s).",
+             upb_fielddef_name(f), rb_class2name(CLASS_OF(val)));
+  }
+
+  for (int i = 0; i < RARRAY_LEN(val); i++) {
+    VALUE entry = rb_ary_entry(val, i);
+    upb_msgval msgval;
+    if (upb_fielddef_issubmsg(f) && TYPE(entry) == T_HASH) {
+      msgval = MessageValue_FromValue(entry, type_info, arena);
+    } else {
+      msgval = Convert_RubyToUpb(entry, upb_fielddef_name(f), type_info, arena);
+    }
+    upb_array_append(arr, msgval, arena);
+  }
+}
+
+static void Message_InitFieldFromValue(upb_msg* msg, const upb_fielddef* f,
+                                       VALUE val, upb_arena* arena) {
+  if (TYPE(val) == T_NIL) return;
+
+  if (upb_fielddef_ismap(f)) {
+    upb_map *map = upb_msg_mutable(msg, f, arena).map;
+    Map_InitFromValue(map, f, val, arena);
+  } else if (upb_fielddef_label(f) == UPB_LABEL_REPEATED) {
+    upb_array *arr = upb_msg_mutable(msg, f, arena).array;
+    RepeatedField_InitFromValue(arr, f, val, arena);
+  } else if (upb_fielddef_issubmsg(f)) {
+    if (TYPE(val) == T_HASH) {
+      upb_msg *submsg = upb_msg_mutable(msg, f, arena).msg;
+      Message_InitFromValue(submsg, upb_fielddef_msgsubdef(f), val, arena);
+    } else {
+      Message_setfield(msg, f, val, arena);
+    }
+  } else {
+    upb_msgval msgval =
+        Convert_RubyToUpb(val, upb_fielddef_name(f), TypeInfo_get(f), arena);
+    upb_msg_set(msg, f, msgval, arena);
+  }
+}
+
+typedef struct {
+  upb_msg *msg;
+  const upb_msgdef *msgdef;
+  upb_arena *arena;
+} MsgInit;
+
+static int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
+  MsgInit *msg_init = (MsgInit*)_self;
+  const char *name;
 
   if (TYPE(key) == T_STRING) {
     name = RSTRING_PTR(key);
@@ -412,51 +589,26 @@ int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
              "Expected string or symbols as hash keys when initializing proto from hash.");
   }
 
-  f = upb_msgdef_ntofz(self->descriptor->msgdef, name);
+  const upb_fielddef* f = upb_msgdef_ntofz(msg_init->msgdef, name);
+
   if (f == NULL) {
     rb_raise(rb_eArgError,
              "Unknown field name '%s' in initialization map entry.", name);
   }
 
-  if (TYPE(val) == T_NIL) {
-    return 0;
-  }
-
-  if (is_map_field(f)) {
-    VALUE map;
-
-    if (TYPE(val) != T_HASH) {
-      rb_raise(rb_eArgError,
-               "Expected Hash object as initializer value for map field '%s' (given %s).",
-               name, rb_class2name(CLASS_OF(val)));
-    }
-    map = layout_get(self->descriptor->layout, Message_data(self), f);
-    Map_merge_into_self(map, val);
-  } else if (upb_fielddef_label(f) == UPB_LABEL_REPEATED) {
-    VALUE ary;
-
-    if (TYPE(val) != T_ARRAY) {
-      rb_raise(rb_eArgError,
-               "Expected array as initializer value for repeated field '%s' (given %s).",
-               name, rb_class2name(CLASS_OF(val)));
-    }
-    ary = layout_get(self->descriptor->layout, Message_data(self), f);
-    for (int i = 0; i < RARRAY_LEN(val); i++) {
-      VALUE entry = rb_ary_entry(val, i);
-      if (TYPE(entry) == T_HASH && upb_fielddef_issubmsg(f)) {
-        entry = create_submsg_from_hash(f, entry);
-      }
+  Message_InitFieldFromValue(msg_init->msg, f, val, msg_init->arena);
+  return ST_CONTINUE;
+}
 
-      RepeatedField_push(ary, entry);
-    }
+void Message_InitFromValue(upb_msg* msg, const upb_msgdef* m, VALUE val,
+                           upb_arena* arena) {
+  MsgInit msg_init = {msg, m, arena};
+  if (TYPE(val) == T_HASH) {
+    rb_hash_foreach(val, Message_initialize_kwarg, (VALUE)&msg_init);
   } else {
-    if (TYPE(val) == T_HASH && upb_fielddef_issubmsg(f)) {
-      val = create_submsg_from_hash(f, val);
-    }
-
-    layout_set(self->descriptor->layout, Message_data(self), f, val);
+    rb_raise(rb_eArgError, "Expected hash arguments or message, not %s",
+             rb_class2name(CLASS_OF(val)));
   }
-  return 0;
 }
 
 /*
@@ -471,8 +623,13 @@ int Message_initialize_kwarg(VALUE key, VALUE val, VALUE _self) {
  * have been added to a pool. The method definitions described here on the
  * Message class are provided on each concrete message class.
  */
-VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
-  VALUE hash_args;
+static VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
+  Message* self = ruby_to_Message(_self);
+  VALUE arena_rb = Arena_new();
+  upb_arena *arena = Arena_get(arena_rb);
+  upb_msg *msg = upb_msg_new(self->msgdef, arena);
+
+  Message_InitPtr(_self, msg, arena_rb);
 
   if (argc == 0) {
     return Qnil;
@@ -480,12 +637,7 @@ VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
   if (argc != 1) {
     rb_raise(rb_eArgError, "Expected 0 or 1 arguments.");
   }
-  hash_args = argv[0];
-  if (TYPE(hash_args) != T_HASH) {
-    rb_raise(rb_eArgError, "Expected hash arguments.");
-  }
-
-  rb_hash_foreach(hash_args, Message_initialize_kwarg, _self);
+  Message_InitFromValue((upb_msg*)self->msg, self->msgdef, argv[0], arena);
   return Qnil;
 }
 
@@ -495,37 +647,40 @@ VALUE Message_initialize(int argc, VALUE* argv, VALUE _self) {
  *
  * Performs a shallow copy of this message and returns the new copy.
  */
-VALUE Message_dup(VALUE _self) {
-  MessageHeader* self;
-  VALUE new_msg;
-  MessageHeader* new_msg_self;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
-
-  new_msg = rb_class_new_instance(0, NULL, CLASS_OF(_self));
-  TypedData_Get_Struct(new_msg, MessageHeader, &Message_type, new_msg_self);
-
-  layout_dup(self->descriptor->layout,
-             Message_data(new_msg_self),
-             Message_data(self));
-
+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_msgdef_layout(self->msgdef)->size;
+
+  // TODO(copy unknown fields?)
+  // TODO(use official upb msg copy function)
+  memcpy((upb_msg*)new_msg_self->msg, self->msg, size);
+  upb_arena_fuse(Arena_get(new_msg_self->arena), Arena_get(self->arena));
   return new_msg;
 }
 
-// Internal only; used by Google::Protobuf.deep_copy.
-VALUE Message_deep_copy(VALUE _self) {
-  MessageHeader* self;
-  MessageHeader* new_msg_self;
-  VALUE new_msg;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
+// Support function for Message_eq, and also used by other #eq functions.
+bool Message_Equal(const upb_msg *m1, const upb_msg *m2, const upb_msgdef *m) {
+  if (m1 == m2) return true;
 
-  new_msg = rb_class_new_instance(0, NULL, CLASS_OF(_self));
-  TypedData_Get_Struct(new_msg, MessageHeader, &Message_type, new_msg_self);
+  size_t size1, size2;
+  int encode_opts = UPB_ENCODE_SKIPUNKNOWN | UPB_ENCODE_DETERMINISTIC;
+  upb_arena *arena_tmp = upb_arena_new();
+  const upb_msglayout *layout = upb_msgdef_layout(m);
 
-  layout_deep_copy(self->descriptor->layout,
-                   Message_data(new_msg_self),
-                   Message_data(self));
+  // Compare deterministically serialized payloads with no unknown fields.
+  char *data1 = upb_encode_ex(m1, layout, encode_opts, arena_tmp, &size1);
+  char *data2 = upb_encode_ex(m2, layout, encode_opts, arena_tmp, &size2);
 
-  return new_msg;
+  if (data1 && data2) {
+    bool ret = (size1 == size2) && (memcmp(data1, data2, size1) == 0);
+    upb_arena_free(arena_tmp);
+    return ret;
+  } else {
+    upb_arena_free(arena_tmp);
+    rb_raise(cParseError, "Error comparing messages");
+  }
 }
 
 /*
@@ -537,22 +692,37 @@ VALUE Message_deep_copy(VALUE _self) {
  * method's semantics (a more efficient comparison may actually be done if the
  * field is of a primitive type).
  */
-VALUE Message_eq(VALUE _self, VALUE _other) {
-  MessageHeader* self;
-  MessageHeader* other;
+static VALUE Message_eq(VALUE _self, VALUE _other) {
   if (TYPE(_self) != TYPE(_other)) {
     return Qfalse;
   }
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
-  TypedData_Get_Struct(_other, MessageHeader, &Message_type, other);
 
-  if (self->descriptor != other->descriptor) {
-    return Qfalse;
-  }
+  Message* self = ruby_to_Message(_self);
+  Message* other = ruby_to_Message(_other);
+
+  return Message_Equal(self->msg, other->msg, self->msgdef)
+             ? Qtrue
+             : Qfalse;
+}
+
+uint64_t Message_Hash(const upb_msg* msg, const upb_msgdef* m, uint64_t seed) {
+  upb_arena *arena = upb_arena_new();
+  const char *data;
+  size_t size;
+
+  // Hash a deterministically serialized payloads with no unknown fields.
+  data = upb_encode_ex(msg, upb_msgdef_layout(m),
+                       UPB_ENCODE_SKIPUNKNOWN | UPB_ENCODE_DETERMINISTIC, arena,
+                       &size);
 
-  return layout_eq(self->descriptor->layout,
-                   Message_data(self),
-                   Message_data(other));
+  if (data) {
+    uint64_t ret = wyhash(data, size, seed, _wyp);
+    upb_arena_free(arena);
+    return ret;
+  } else {
+    upb_arena_free(arena);
+    rb_raise(cParseError, "Error calculating hash");
+  }
 }
 
 /*
@@ -561,11 +731,9 @@ VALUE Message_eq(VALUE _self, VALUE _other) {
  *
  * Returns a hash value that represents this message's field values.
  */
-VALUE Message_hash(VALUE _self) {
-  MessageHeader* self;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
-
-  return layout_hash(self->descriptor->layout, Message_data(self));
+static VALUE Message_hash(VALUE _self) {
+  Message* self = ruby_to_Message(_self);
+  return INT2FIX(Message_Hash(self->msg, self->msgdef, 0));
 }
 
 /*
@@ -576,75 +744,117 @@ VALUE Message_hash(VALUE _self) {
  * formatted as "<MessageType: field1: value1, field2: value2, ...>". Each
  * field's value is represented according to its own #inspect method.
  */
-VALUE Message_inspect(VALUE _self) {
-  MessageHeader* self;
-  VALUE str;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
+static VALUE Message_inspect(VALUE _self) {
+  Message* self = ruby_to_Message(_self);
 
-  str = rb_str_new2("<");
-  str = rb_str_append(str, rb_str_new2(rb_class2name(CLASS_OF(_self))));
-  str = rb_str_cat2(str, ": ");
-  str = rb_str_append(str, layout_inspect(
-      self->descriptor->layout, Message_data(self)));
-  str = rb_str_cat2(str, ">");
-  return str;
+  StringBuilder* builder = StringBuilder_New();
+  Message_PrintMessage(builder, self->msg, self->msgdef);
+  VALUE ret = StringBuilder_ToRubyString(builder);
+  StringBuilder_Free(builder);
+  return ret;
 }
 
-/*
- * call-seq:
- *     Message.to_h => {}
- *
- * Returns the message as a Ruby Hash object, with keys as symbols.
- */
-VALUE Message_to_h(VALUE _self) {
-  MessageHeader* self;
-  VALUE hash;
-  upb_msg_field_iter it;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
-
-  hash = rb_hash_new();
-
-  for (upb_msg_field_begin(&it, self->descriptor->msgdef);
-       !upb_msg_field_done(&it);
-       upb_msg_field_next(&it)) {
-    const upb_fielddef* field = upb_msg_iter_field(&it);
-
-    // For proto2, do not include fields which are not set.
-    if (upb_msgdef_syntax(self->descriptor->msgdef) == UPB_SYNTAX_PROTO2 &&
-	field_contains_hasbit(self->descriptor->layout, field) &&
-	!layout_has(self->descriptor->layout, Message_data(self), field)) {
+// Support functions for Message_to_h //////////////////////////////////////////
+
+static VALUE RepeatedField_CreateArray(const upb_array* arr,
+                                       TypeInfo type_info) {
+  int size = arr ? upb_array_size(arr) : 0;
+  VALUE ary = rb_ary_new2(size);
+
+  for (int i = 0; i < size; i++) {
+    upb_msgval msgval = upb_array_get(arr, i);
+    VALUE val = Scalar_CreateHash(msgval, type_info);
+    rb_ary_push(ary, val);
+  }
+
+  return ary;
+}
+
+static VALUE Message_CreateHash(const upb_msg *msg, const upb_msgdef *m) {
+  if (!msg) return Qnil;
+
+  VALUE hash = rb_hash_new();
+  int n = upb_msgdef_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_msgdef_syntax(m) == UPB_SYNTAX_PROTO2;
+
+  for (int i = 0; i < n; i++) {
+    const upb_fielddef* field = upb_msgdef_field(m, i);
+    TypeInfo type_info = TypeInfo_get(field);
+    upb_msgval msgval;
+    VALUE msg_value;
+    VALUE msg_key;
+
+    // Do not include fields that are not present (oneof or optional fields).
+    if (is_proto2 && upb_fielddef_haspresence(field) &&
+        !upb_msg_has(msg, field)) {
       continue;
     }
 
-    VALUE msg_value = layout_get(self->descriptor->layout, Message_data(self),
-                                 field);
-    VALUE msg_key   = ID2SYM(rb_intern(upb_fielddef_name(field)));
-    if (is_map_field(field)) {
-      msg_value = Map_to_h(msg_value);
-    } else if (upb_fielddef_label(field) == UPB_LABEL_REPEATED) {
-      msg_value = RepeatedField_to_ary(msg_value);
-      if (upb_msgdef_syntax(self->descriptor->msgdef) == UPB_SYNTAX_PROTO2 &&
-          RARRAY_LEN(msg_value) == 0) {
-        continue;
-      }
+    msg_key = ID2SYM(rb_intern(upb_fielddef_name(field)));
+    msgval = upb_msg_get(msg, field);
 
-      if (upb_fielddef_type(field) == UPB_TYPE_MESSAGE) {
-        for (int i = 0; i < RARRAY_LEN(msg_value); i++) {
-          VALUE elem = rb_ary_entry(msg_value, i);
-          rb_ary_store(msg_value, i, Message_to_h(elem));
-        }
-      }
+    // Proto2 omits empty map/repeated filds also.
 
-    } else if (msg_value != Qnil &&
-               upb_fielddef_type(field) == UPB_TYPE_MESSAGE) {
-      msg_value = Message_to_h(msg_value);
+    if (upb_fielddef_ismap(field)) {
+      const upb_msgdef *entry_m = upb_fielddef_msgsubdef(field);
+      const upb_fielddef *key_f = upb_msgdef_itof(entry_m, 1);
+      const upb_fielddef *val_f = upb_msgdef_itof(entry_m, 2);
+      upb_fieldtype_t key_type = upb_fielddef_type(key_f);
+      msg_value = Map_CreateHash(msgval.map_val, key_type, TypeInfo_get(val_f));
+    } else if (upb_fielddef_isseq(field)) {
+      if (is_proto2 &&
+          (!msgval.array_val || upb_array_size(msgval.array_val) == 0)) {
+        continue;
+      }
+      msg_value = RepeatedField_CreateArray(msgval.array_val, type_info);
+    } else {
+      msg_value = Scalar_CreateHash(msgval, type_info);
     }
+
     rb_hash_aset(hash, msg_key, msg_value);
   }
+
   return hash;
 }
 
+VALUE Scalar_CreateHash(upb_msgval msgval, TypeInfo type_info) {
+  if (type_info.type == UPB_TYPE_MESSAGE) {
+    return Message_CreateHash(msgval.msg_val, type_info.def.msgdef);
+  } else {
+    return Convert_UpbToRuby(msgval, type_info, Qnil);
+  }
+}
 
+/*
+ * call-seq:
+ *     Message.to_h => {}
+ *
+ * Returns the message as a Ruby Hash object, with keys as symbols.
+ */
+static VALUE Message_to_h(VALUE _self) {
+  Message* self = ruby_to_Message(_self);
+  return Message_CreateHash(self->msg, self->msgdef);
+}
+
+/*
+ * call-seq:
+ *     Message.freeze => self
+ *
+ * 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.
+ */
+static VALUE Message_freeze(VALUE _self) {
+  Message* self = ruby_to_Message(_self);
+  ObjectCache_Pin(self->msg, _self, Arena_get(self->arena));
+  RB_OBJ_FREEZE(_self);
+  return _self;
+}
 
 /*
  * call-seq:
@@ -653,16 +863,20 @@ VALUE Message_to_h(VALUE _self) {
  * Accesses a field's value by field name. The provided field name should be a
  * string.
  */
-VALUE Message_index(VALUE _self, VALUE field_name) {
-  MessageHeader* self;
+static VALUE Message_index(VALUE _self, VALUE field_name) {
+  Message* self = ruby_to_Message(_self);
   const upb_fielddef* field;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
+  upb_msgval val;
+
   Check_Type(field_name, T_STRING);
-  field = upb_msgdef_ntofz(self->descriptor->msgdef, RSTRING_PTR(field_name));
+  field = upb_msgdef_ntofz(self->msgdef, RSTRING_PTR(field_name));
+
   if (field == NULL) {
     return Qnil;
   }
-  return layout_get(self->descriptor->layout, Message_data(self), field);
+
+  val = upb_msg_get(self->msg, field);
+  return Convert_UpbToRuby(val, TypeInfo_get(field), self->arena);
 }
 
 /*
@@ -672,19 +886,208 @@ VALUE Message_index(VALUE _self, VALUE field_name) {
  * Sets a field's value by field name. The provided field name should be a
  * string.
  */
-VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
-  MessageHeader* self;
-  const upb_fielddef* field;
-  TypedData_Get_Struct(_self, MessageHeader, &Message_type, self);
+static VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
+  Message* self = ruby_to_Message(_self);
+  const upb_fielddef* f;
+  upb_msgval val;
+  upb_arena *arena = Arena_get(self->arena);
+
   Check_Type(field_name, T_STRING);
-  field = upb_msgdef_ntofz(self->descriptor->msgdef, RSTRING_PTR(field_name));
-  if (field == NULL) {
+  f = upb_msgdef_ntofz(self->msgdef, RSTRING_PTR(field_name));
+
+  if (f == NULL) {
     rb_raise(rb_eArgError, "Unknown field: %s", RSTRING_PTR(field_name));
   }
-  layout_set(self->descriptor->layout, Message_data(self), field, value);
+
+  val = Convert_RubyToUpb(value, upb_fielddef_name(f), TypeInfo_get(f), arena);
+  upb_msg_set(Message_GetMutable(_self, NULL), f, val, arena);
+
   return Qnil;
 }
 
+/*
+ * call-seq:
+ *     MessageClass.decode(data) => message
+ *
+ * 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.
+ */
+static VALUE Message_decode(VALUE klass, VALUE data) {
+  if (TYPE(data) != T_STRING) {
+    rb_raise(rb_eArgError, "Expected string for binary protobuf data.");
+  }
+
+  VALUE msg_rb = initialize_rb_class_with_no_args(klass);
+  Message* msg = ruby_to_Message(msg_rb);
+
+  if (!upb_decode(RSTRING_PTR(data), RSTRING_LEN(data), (upb_msg*)msg->msg,
+                 upb_msgdef_layout(msg->msgdef),
+                 Arena_get(msg->arena))) {
+    rb_raise(cParseError, "Error occurred during parsing");
+  }
+
+  return msg_rb;
+}
+
+/*
+ * call-seq:
+ *     MessageClass.decode_json(data, options = {}) => message
+ *
+ * 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)
+ */
+static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
+  VALUE data = argv[0];
+  int options = 0;
+  upb_status status;
+
+  // TODO(haberman): use this message's pool instead.
+  const upb_symtab *symtab = DescriptorPool_GetSymtab(generated_pool);
+
+  if (argc < 1 || argc > 2) {
+    rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
+  }
+
+  if (argc == 2) {
+    VALUE hash_args = argv[1];
+    if (TYPE(hash_args) != T_HASH) {
+      rb_raise(rb_eArgError, "Expected hash arguments.");
+    }
+
+    if (RTEST(rb_hash_lookup2( hash_args, ID2SYM(rb_intern("ignore_unknown_fields")), Qfalse))) {
+      options |= UPB_JSONDEC_IGNOREUNKNOWN;
+    }
+  }
+
+  if (TYPE(data) != T_STRING) {
+    rb_raise(rb_eArgError, "Expected string for JSON data.");
+  }
+
+  // TODO(cfallin): Check and respect string encoding. If not UTF-8, we need to
+  // convert, because string handlers pass data directly to message string
+  // fields.
+
+  VALUE msg_rb = initialize_rb_class_with_no_args(klass);
+  Message* msg = ruby_to_Message(msg_rb);
+
+  // We don't allow users to decode a wrapper type directly.
+  if (upb_msgdef_iswrapper(msg->msgdef)) {
+    rb_raise(rb_eRuntimeError, "Cannot parse a wrapper directly.");
+  }
+
+  upb_status_clear(&status);
+  if (!upb_json_decode(RSTRING_PTR(data), RSTRING_LEN(data), (upb_msg*)msg->msg,
+                       msg->msgdef, symtab, options,
+                       Arena_get(msg->arena), &status)) {
+    rb_raise(cParseError, "Error occurred during parsing: %s",
+             upb_status_errmsg(&status));
+  }
+
+  return msg_rb;
+}
+
+/*
+ * call-seq:
+ *     MessageClass.encode(msg) => bytes
+ *
+ * Encodes the given message object to its serialized form in protocol buffers
+ * wire format.
+ */
+static VALUE Message_encode(VALUE klass, VALUE msg_rb) {
+  Message* msg = ruby_to_Message(msg_rb);
+  upb_arena *arena = upb_arena_new();
+  const char *data;
+  size_t size;
+
+  if (CLASS_OF(msg_rb) != klass) {
+    rb_raise(rb_eArgError, "Message of wrong type.");
+  }
+
+  data = upb_encode(msg->msg, upb_msgdef_layout(msg->msgdef), arena,
+                    &size);
+
+  if (data) {
+    VALUE ret = rb_str_new(data, size);
+    rb_enc_associate(ret, rb_ascii8bit_encoding());
+    upb_arena_free(arena);
+    return ret;
+  } else {
+    upb_arena_free(arena);
+    rb_raise(rb_eRuntimeError, "Exceeded maximum depth (possibly cycle)");
+  }
+}
+
+/*
+ * call-seq:
+ *     MessageClass.encode_json(msg, options = {}) => json_string
+ *
+ * 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)
+ */
+static VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
+  Message* msg = ruby_to_Message(argv[0]);
+  int options = 0;
+  char buf[1024];
+  size_t size;
+  upb_status status;
+
+  // TODO(haberman): use this message's pool instead.
+  const upb_symtab *symtab = DescriptorPool_GetSymtab(generated_pool);
+
+  if (argc < 1 || argc > 2) {
+    rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
+  }
+
+  if (argc == 2) {
+    VALUE hash_args = argv[1];
+    if (TYPE(hash_args) != T_HASH) {
+      rb_raise(rb_eArgError, "Expected hash arguments.");
+    }
+
+    if (RTEST(rb_hash_lookup2(hash_args,
+                              ID2SYM(rb_intern("preserve_proto_fieldnames")),
+                              Qfalse))) {
+      options |= UPB_JSONENC_PROTONAMES;
+    }
+
+    if (RTEST(rb_hash_lookup2(hash_args, ID2SYM(rb_intern("emit_defaults")),
+                              Qfalse))) {
+      options |= UPB_JSONENC_EMITDEFAULTS;
+    }
+  }
+
+  upb_status_clear(&status);
+  size = upb_json_encode(msg->msg, msg->msgdef, symtab, options, buf,
+                         sizeof(buf), &status);
+
+  if (!upb_ok(&status)) {
+    rb_raise(cParseError, "Error occurred during encoding: %s",
+             upb_status_errmsg(&status));
+  }
+
+  VALUE ret;
+  if (size >= sizeof(buf)) {
+    char* buf2 = malloc(size + 1);
+    upb_json_encode(msg->msg, msg->msgdef, symtab, options, buf2, size + 1,
+                    &status);
+    ret = rb_str_new(buf2, size);
+    free(buf2);
+  } else {
+    ret = rb_str_new(buf, size);
+  }
+
+  rb_enc_associate(ret, rb_utf8_encoding());
+  return ret;
+}
+
 /*
  * call-seq:
  *     Message.descriptor => descriptor
@@ -692,22 +1095,15 @@ VALUE Message_index_set(VALUE _self, VALUE field_name, VALUE value) {
  * Class method that returns the Descriptor instance corresponding to this
  * message class's type.
  */
-VALUE Message_descriptor(VALUE klass) {
+static VALUE Message_descriptor(VALUE klass) {
   return rb_ivar_get(klass, descriptor_instancevar_interned);
 }
 
-VALUE build_class_from_descriptor(Descriptor* desc) {
+VALUE build_class_from_descriptor(VALUE descriptor) {
   const char *name;
   VALUE klass;
 
-  if (desc->layout == NULL) {
-    desc->layout = create_layout(desc->msgdef);
-  }
-  if (desc->fill_method == NULL) {
-    desc->fill_method = new_fillmsg_decodermethod(desc, &desc->fill_method);
-  }
-
-  name = upb_msgdef_fullname(desc->msgdef);
+  name = upb_msgdef_fullname(Descriptor_GetMsgDef(descriptor));
   if (name == NULL) {
     rb_raise(rb_eRuntimeError, "Descriptor does not have assigned name.");
   }
@@ -717,8 +1113,7 @@ VALUE build_class_from_descriptor(Descriptor* desc) {
       // their own toplevel constant class name.
       rb_intern("Message"),
       rb_cObject);
-  rb_ivar_set(klass, descriptor_instancevar_interned,
-              get_def_obj(desc->msgdef));
+  rb_ivar_set(klass, descriptor_instancevar_interned, descriptor);
   rb_define_alloc_func(klass, Message_alloc);
   rb_require("google/protobuf/message_exts");
   rb_include_module(klass, rb_eval_string("::Google::Protobuf::MessageExts"));
@@ -735,9 +1130,9 @@ VALUE build_class_from_descriptor(Descriptor* desc) {
   rb_define_method(klass, "clone", Message_dup, 0);
   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, "hash", Message_hash, 0);
   rb_define_method(klass, "to_h", Message_to_h, 0);
-  rb_define_method(klass, "to_hash", Message_to_h, 0);
   rb_define_method(klass, "inspect", Message_inspect, 0);
   rb_define_method(klass, "to_s", Message_inspect, 0);
   rb_define_method(klass, "[]", Message_index, 1);
@@ -758,12 +1153,12 @@ VALUE build_class_from_descriptor(Descriptor* desc) {
  * 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.
  */
-VALUE enum_lookup(VALUE self, VALUE number) {
+static VALUE enum_lookup(VALUE self, VALUE number) {
   int32_t num = NUM2INT(number);
   VALUE desc = rb_ivar_get(self, descriptor_instancevar_interned);
-  EnumDescriptor* enumdesc = ruby_to_EnumDescriptor(desc);
+  const upb_enumdef *e = EnumDescriptor_GetEnumDef(desc);
 
-  const char* name = upb_enumdef_iton(enumdesc->enumdef, num);
+  const char* name = upb_enumdef_iton(e, num);
   if (name == NULL) {
     return Qnil;
   } else {
@@ -778,13 +1173,13 @@ VALUE enum_lookup(VALUE self, VALUE number) {
  * 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.
  */
-VALUE enum_resolve(VALUE self, VALUE sym) {
+static VALUE enum_resolve(VALUE self, VALUE sym) {
   const char* name = rb_id2name(SYM2ID(sym));
   VALUE desc = rb_ivar_get(self, descriptor_instancevar_interned);
-  EnumDescriptor* enumdesc = ruby_to_EnumDescriptor(desc);
+  const upb_enumdef *e = EnumDescriptor_GetEnumDef(desc);
 
   int32_t num = 0;
-  bool found = upb_enumdef_ntoiz(enumdesc->enumdef, name, &num);
+  bool found = upb_enumdef_ntoiz(e, name, &num);
   if (!found) {
     return Qnil;
   } else {
@@ -799,16 +1194,16 @@ VALUE enum_resolve(VALUE self, VALUE sym) {
  * This module method, provided on each generated enum module, returns the
  * EnumDescriptor corresponding to this enum type.
  */
-VALUE enum_descriptor(VALUE self) {
+static VALUE enum_descriptor(VALUE self) {
   return rb_ivar_get(self, descriptor_instancevar_interned);
 }
 
-VALUE build_module_from_enumdesc(EnumDescriptor* enumdesc) {
-  VALUE mod = rb_define_module_id(
-      rb_intern(upb_enumdef_fullname(enumdesc->enumdef)));
+VALUE build_module_from_enumdesc(VALUE _enumdesc) {
+  const upb_enumdef *e = EnumDescriptor_GetEnumDef(_enumdesc);
+  VALUE mod = rb_define_module_id(rb_intern(upb_enumdef_fullname(e)));
 
   upb_enum_iter it;
-  for (upb_enum_begin(&it, enumdesc->enumdef);
+  for (upb_enum_begin(&it, e);
        !upb_enum_done(&it);
        upb_enum_next(&it)) {
     const char* name = upb_enum_iter_name(&it);
@@ -824,26 +1219,97 @@ VALUE build_module_from_enumdesc(EnumDescriptor* enumdesc) {
   rb_define_singleton_method(mod, "lookup", enum_lookup, 1);
   rb_define_singleton_method(mod, "resolve", enum_resolve, 1);
   rb_define_singleton_method(mod, "descriptor", enum_descriptor, 0);
-  rb_ivar_set(mod, descriptor_instancevar_interned,
-              get_def_obj(enumdesc->enumdef));
+  rb_ivar_set(mod, descriptor_instancevar_interned, _enumdesc);
 
   return mod;
 }
 
-/*
- * call-seq:
- *     Google::Protobuf.deep_copy(obj) => copy_of_obj
- *
- * Performs a deep copy of a RepeatedField instance, a Map instance, or a
- * message object, recursively copying its members.
- */
-VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj) {
-  VALUE klass = CLASS_OF(obj);
-  if (klass == cRepeatedField) {
-    return RepeatedField_deep_copy(obj);
-  } else if (klass == cMap) {
-    return Map_deep_copy(obj);
-  } else {
-    return Message_deep_copy(obj);
+// Internal only; used by Google::Protobuf.deep_copy.
+upb_msg* Message_deep_copy(const upb_msg* msg, const upb_msgdef* m,
+                           upb_arena *arena) {
+  // Serialize and parse.
+  upb_arena *tmp_arena = upb_arena_new();
+  const upb_msglayout *layout = upb_msgdef_layout(m);
+  size_t size;
+
+  char* data = upb_encode_ex(msg, layout, 0, tmp_arena, &size);
+  upb_msg* new_msg = upb_msg_new(m, arena);
+
+  if (!data || !upb_decode(data, size, new_msg, layout, arena)) {
+    upb_arena_free(tmp_arena);
+    rb_raise(cParseError, "Error occurred copying proto");
   }
+
+  upb_arena_free(tmp_arena);
+  return new_msg;
+}
+
+const upb_msg* Message_GetUpbMessage(VALUE value, const upb_msgdef* m,
+                                     const char* name, upb_arena* arena) {
+  if (value == Qnil) return NULL;
+
+  VALUE klass = CLASS_OF(value);
+  VALUE desc_rb = rb_ivar_get(klass, descriptor_instancevar_interned);
+  const upb_msgdef* val_m =
+      desc_rb == Qnil ? NULL : Descriptor_GetMsgDef(desc_rb);
+
+  if (val_m != m) {
+    // Check for possible implicit conversions
+    // TODO: hash conversion?
+
+    switch (upb_msgdef_wellknowntype(m)) {
+      case UPB_WELLKNOWN_TIMESTAMP: {
+        // Time -> Google::Protobuf::Timestamp
+        upb_msg *msg = upb_msg_new(m, arena);
+        upb_msgval sec, nsec;
+        struct timespec time;
+        const upb_fielddef *sec_f = upb_msgdef_itof(m, 1);
+        const upb_fielddef *nsec_f = upb_msgdef_itof(m, 2);
+
+        if (!rb_obj_is_kind_of(value, rb_cTime)) goto badtype;
+
+        time = rb_time_timespec(value);
+        sec.int64_val = time.tv_sec;
+        nsec.int32_val = time.tv_nsec;
+        upb_msg_set(msg, sec_f, sec, arena);
+        upb_msg_set(msg, nsec_f, nsec, arena);
+        return msg;
+      }
+      case UPB_WELLKNOWN_DURATION: {
+        // Numeric -> Google::Protobuf::Duration
+        upb_msg *msg = upb_msg_new(m, arena);
+        upb_msgval sec, nsec;
+        const upb_fielddef *sec_f = upb_msgdef_itof(m, 1);
+        const upb_fielddef *nsec_f = upb_msgdef_itof(m, 2);
+
+        if (!rb_obj_is_kind_of(value, rb_cNumeric)) goto badtype;
+
+        sec.int64_val = NUM2LL(value);
+        nsec.int32_val = (NUM2DBL(value) - NUM2LL(value)) * 1000000000;
+        upb_msg_set(msg, sec_f, sec, arena);
+        upb_msg_set(msg, nsec_f, nsec, arena);
+        return msg;
+      }
+      default:
+      badtype:
+        rb_raise(cTypeError,
+                 "Invalid type %s to assign to submessage field '%s'.",
+                rb_class2name(CLASS_OF(value)), name);
+    }
+
+  }
+
+  Message* self = ruby_to_Message(value);
+  upb_arena_fuse(arena, Arena_get(self->arena));
+
+  return self->msg;
+}
+
+void Message_register(VALUE protobuf) {
+  cParseError = rb_const_get(protobuf, rb_intern("ParseError"));
+
+  // Ruby-interned string: "descriptor". We use this identifier to store an
+  // instance variable on message classes we create in order to link them back
+  // to their descriptors.
+  descriptor_instancevar_interned = rb_intern("descriptor");
 }