google-protobuf 3.9.2-x64-mingw32 → 3.10.0.rc.1-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05119520ca900be39ac63ef834f2077da21bafa511d65b213f2a257225c319b9'
-  data.tar.gz: ed0669c4c313e0ba4d3344b29e1f722f6c6f9086236c522e41c9cff32fdd461e
+  metadata.gz: a7740fcdceef1e14dd5b0959a10b0165fb5d0b843986b646fd228bc86c65bac6
+  data.tar.gz: 0530aa4dc7cb4fd6d52784dc0ca4ba309a9c0a353e949ff6cad8df15f820b6de
 SHA512:
-  metadata.gz: a5031d94295f3c6bbad0265faea15cd2965340dd9f93892396b2156f5da7338e9c58c1a881d20c93c1a6e43c89b461ccdee2c0522cca56ab6e79980bbe6861f6
-  data.tar.gz: 5a2d543a4c12141810941e6d0da7aa695fca7e824864e3a62a23d35e4d67761a29b5ffd1296ea94abebac05c438f0e27c7318738a5fae140cb6d2db330ba4392
+  metadata.gz: ea4bfefbcd3ca7742a0831116e03ffada82c8c1d90b17676004e65a2ea9ed81282614b97288caea5343e53a0a0befabfeb458d9dd4afb0aa404db630a91aaaa8
+  data.tar.gz: 1665adc6eb0013fe6e2b9a6ec883324bff929b0d4f8535f2b3967a1a3e102338c75e7d0137e632d58e7f8cda28b30e703db39157651913b5878dfddd0150f2fb

data/ext/google/protobuf_c/defs.c

@@ -28,6 +28,8 @@
 // (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 <ctype.h>
+#include <errno.h>
 #include "protobuf.h"
 
 // -----------------------------------------------------------------------------
@@ -46,29 +48,290 @@ static VALUE rb_str_maybe_null(const char* s) {
   return rb_str_new2(s);
 }
 
-static upb_def* check_notfrozen(const upb_def* def) {
-  if (upb_def_isfrozen(def)) {
-    rb_raise(rb_eRuntimeError,
-             "Attempt to modify a frozen descriptor. Once descriptors are "
-             "added to the descriptor pool, they may not be modified.");
+static void rewrite_enum_default(const upb_symtab* symtab,
+                                 google_protobuf_FileDescriptorProto* file,
+                                 google_protobuf_FieldDescriptorProto* field) {
+  upb_strview defaultval;
+  const char *type_name_str;
+  char *end;
+  long val;
+  const upb_enumdef *e;
+  upb_strview type_name;
+
+  /* Look for TYPE_ENUM fields that have a default. */
+  if (google_protobuf_FieldDescriptorProto_type(field) !=
+          google_protobuf_FieldDescriptorProto_TYPE_ENUM ||
+      !google_protobuf_FieldDescriptorProto_has_default_value(field) ||
+      !google_protobuf_FieldDescriptorProto_has_type_name(field)) {
+    return;
   }
-  return (upb_def*)def;
-}
 
-static upb_msgdef* check_msg_notfrozen(const upb_msgdef* def) {
-  return upb_downcast_msgdef_mutable(check_notfrozen((const upb_def*)def));
+  defaultval = google_protobuf_FieldDescriptorProto_default_value(field);
+  type_name = google_protobuf_FieldDescriptorProto_type_name(field);
+
+  if (defaultval.size == 0 || !isdigit(defaultval.data[0])) {
+    return;
+  }
+
+  if (type_name.size == 0 || type_name.data[0] != '.') {
+    return;
+  }
+
+  type_name_str = type_name.data + 1;
+
+  errno = 0;
+  val = strtol(defaultval.data, &end, 10);
+
+  if (errno != 0 || *end != 0 || val < INT32_MIN || val > INT32_MAX) {
+    return;
+  }
+
+  /* Now find the corresponding enum definition. */
+  e = upb_symtab_lookupenum(symtab, type_name_str);
+  if (e) {
+    /* Look in previously loaded files. */
+    const char *label = upb_enumdef_iton(e, val);
+    if (!label) {
+      return;
+    }
+    google_protobuf_FieldDescriptorProto_set_default_value(
+        field, upb_strview_makez(label));
+  } else {
+    /* Look in enums defined in this file. */
+    const google_protobuf_EnumDescriptorProto* matching_enum = NULL;
+    size_t i, n;
+    const google_protobuf_EnumDescriptorProto* const* enums =
+        google_protobuf_FileDescriptorProto_enum_type(file, &n);
+    const google_protobuf_EnumValueDescriptorProto* const* values;
+
+    for (i = 0; i < n; i++) {
+      if (upb_strview_eql(google_protobuf_EnumDescriptorProto_name(enums[i]),
+                          upb_strview_makez(type_name_str))) {
+        matching_enum = enums[i];
+        break;
+      }
+    }
+
+    if (!matching_enum) {
+      return;
+    }
+
+    values = google_protobuf_EnumDescriptorProto_value(matching_enum, &n);
+    for (i = 0; i < n; i++) {
+      if (google_protobuf_EnumValueDescriptorProto_number(values[i]) == val) {
+        google_protobuf_FieldDescriptorProto_set_default_value(
+            field, google_protobuf_EnumValueDescriptorProto_name(values[i]));
+        return;
+      }
+    }
+
+    /* We failed to find an enum default.  But we'll just leave the enum
+     * untouched and let the normal def-building code catch it. */
+  }
 }
 
-static upb_fielddef* check_field_notfrozen(const upb_fielddef* def) {
-  return upb_downcast_fielddef_mutable(check_notfrozen((const upb_def*)def));
+/* Historically we allowed enum defaults to be specified as a number.  In
+ * retrospect this was a mistake as descriptors require defaults to be
+ * specified as a label. This can make a difference if multiple labels have the
+ * same number.
+ *
+ * Here we do a pass over all enum defaults and rewrite numeric defaults by
+ * looking up their labels.  This is compilcated by the fact that the enum
+ * definition can live in either the symtab or the file_proto.
+ * */
+static void rewrite_enum_defaults(
+    const upb_symtab* symtab, google_protobuf_FileDescriptorProto* file_proto) {
+  size_t i, n;
+  google_protobuf_DescriptorProto** msgs =
+      google_protobuf_FileDescriptorProto_mutable_message_type(file_proto, &n);
+
+  for (i = 0; i < n; i++) {
+    size_t j, m;
+    google_protobuf_FieldDescriptorProto** fields =
+        google_protobuf_DescriptorProto_mutable_field(msgs[i], &m);
+    for (j = 0; j < m; j++) {
+      rewrite_enum_default(symtab, file_proto, fields[j]);
+    }
+  }
 }
 
-static upb_oneofdef* check_oneof_notfrozen(const upb_oneofdef* def) {
-  return (upb_oneofdef*)check_notfrozen((const upb_def*)def);
+static void remove_path(upb_strview *name) {
+  const char* last = strrchr(name->data, '.');
+  if (last) {
+    size_t remove = last - name->data + 1;
+    name->data += remove;
+    name->size -= remove;
+  }
+}
+
+static void rewrite_nesting(VALUE msg_ent, google_protobuf_DescriptorProto* msg,
+                            google_protobuf_DescriptorProto* const* msgs,
+                            google_protobuf_EnumDescriptorProto* const* enums,
+                            upb_arena *arena) {
+  VALUE submsgs = rb_hash_aref(msg_ent, ID2SYM(rb_intern("msgs")));
+  VALUE enum_pos = rb_hash_aref(msg_ent, ID2SYM(rb_intern("enums")));
+  int submsg_count;
+  int enum_count;
+  int i;
+  google_protobuf_DescriptorProto** msg_msgs;
+  google_protobuf_EnumDescriptorProto** msg_enums;
+
+  Check_Type(submsgs, T_ARRAY);
+  Check_Type(enum_pos, T_ARRAY);
+
+  submsg_count = RARRAY_LEN(submsgs);
+  enum_count = RARRAY_LEN(enum_pos);
+
+  msg_msgs = google_protobuf_DescriptorProto_resize_nested_type(
+      msg, submsg_count, arena);
+  msg_enums =
+      google_protobuf_DescriptorProto_resize_enum_type(msg, enum_count, arena);
+
+  for (i = 0; i < submsg_count; i++) {
+    VALUE submsg_ent = RARRAY_PTR(submsgs)[i];
+    VALUE pos = rb_hash_aref(submsg_ent, ID2SYM(rb_intern("pos")));
+    upb_strview name;
+
+    msg_msgs[i] = msgs[NUM2INT(pos)];
+    name = google_protobuf_DescriptorProto_name(msg_msgs[i]);
+    remove_path(&name);
+    google_protobuf_DescriptorProto_set_name(msg_msgs[i], name);
+    rewrite_nesting(submsg_ent, msg_msgs[i], msgs, enums, arena);
+  }
+
+  for (i = 0; i < enum_count; i++) {
+    VALUE pos = RARRAY_PTR(enum_pos)[i];
+    msg_enums[i] = enums[NUM2INT(pos)];
+  }
 }
 
-static upb_enumdef* check_enum_notfrozen(const upb_enumdef* def) {
-  return (upb_enumdef*)check_notfrozen((const upb_def*)def);
+/* We have to do some relatively complicated logic here for backward
+ * compatibility.
+ *
+ * In descriptor.proto, messages are nested inside other messages if that is
+ * what the original .proto file looks like.  For example, suppose we have this
+ * foo.proto:
+ *
+ * package foo;
+ * message Bar {
+ *   message Baz {}
+ * }
+ *
+ * The descriptor for this must look like this:
+ *
+ * file {
+ *   name: "test.proto"
+ *   package: "foo"
+ *   message_type {
+ *     name: "Bar"
+ *     nested_type {
+ *       name: "Baz"
+ *     }
+ *   }
+ * }
+ *
+ * However, the Ruby generated code has always generated messages in a flat,
+ * non-nested way:
+ *
+ * Google::Protobuf::DescriptorPool.generated_pool.build do
+ *   add_message "foo.Bar" do
+ *   end
+ *   add_message "foo.Bar.Baz" do
+ *   end
+ * end
+ *
+ * Here we need to do a translation where we turn this generated code into the
+ * above descriptor.  We need to infer that "foo" is the package name, and not
+ * a message itself.
+ *
+ * We delegate to Ruby to compute the transformation, for more concice and
+ * readable code than we can do in C */
+static void rewrite_names(VALUE _file_builder,
+                          google_protobuf_FileDescriptorProto* file_proto) {
+  FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
+  upb_arena *arena = file_builder->arena;
+  // Build params (package, msg_names, enum_names).
+  VALUE package = Qnil;
+  VALUE msg_names = rb_ary_new();
+  VALUE enum_names = rb_ary_new();
+  size_t msg_count, enum_count, i;
+  VALUE new_package, nesting, msg_ents, enum_ents;
+  google_protobuf_DescriptorProto** msgs;
+  google_protobuf_EnumDescriptorProto** enums;
+
+  if (google_protobuf_FileDescriptorProto_has_package(file_proto)) {
+    upb_strview package_str =
+        google_protobuf_FileDescriptorProto_package(file_proto);
+    package = rb_str_new(package_str.data, package_str.size);
+  }
+
+  msgs = google_protobuf_FileDescriptorProto_mutable_message_type(file_proto,
+                                                                  &msg_count);
+  for (i = 0; i < msg_count; i++) {
+    upb_strview name = google_protobuf_DescriptorProto_name(msgs[i]);
+    rb_ary_push(msg_names, rb_str_new(name.data, name.size));
+  }
+
+  enums = google_protobuf_FileDescriptorProto_mutable_enum_type(file_proto,
+                                                                &enum_count);
+  for (i = 0; i < enum_count; i++) {
+    upb_strview name = google_protobuf_EnumDescriptorProto_name(enums[i]);
+    rb_ary_push(enum_names, rb_str_new(name.data, name.size));
+  }
+
+  {
+    // Call Ruby code to calculate package name and nesting.
+    VALUE args[3] = { package, msg_names, enum_names };
+    VALUE internal = rb_eval_string("Google::Protobuf::Internal");
+    VALUE ret = rb_funcallv(internal, rb_intern("fixup_descriptor"), 3, args);
+
+    new_package = rb_ary_entry(ret, 0);
+    nesting = rb_ary_entry(ret, 1);
+  }
+
+  // Rewrite package and names.
+  if (new_package != Qnil) {
+    upb_strview new_package_str =
+        FileBuilderContext_strdup(_file_builder, new_package);
+    google_protobuf_FileDescriptorProto_set_package(file_proto,
+                                                    new_package_str);
+  }
+
+  for (i = 0; i < msg_count; i++) {
+    upb_strview name = google_protobuf_DescriptorProto_name(msgs[i]);
+    remove_path(&name);
+    google_protobuf_DescriptorProto_set_name(msgs[i], name);
+  }
+
+  for (i = 0; i < enum_count; i++) {
+    upb_strview name = google_protobuf_EnumDescriptorProto_name(enums[i]);
+    remove_path(&name);
+    google_protobuf_EnumDescriptorProto_set_name(enums[i], name);
+  }
+
+  // Rewrite nesting.
+  msg_ents = rb_hash_aref(nesting, ID2SYM(rb_intern("msgs")));
+  enum_ents = rb_hash_aref(nesting, ID2SYM(rb_intern("enums")));
+
+  Check_Type(msg_ents, T_ARRAY);
+  Check_Type(enum_ents, T_ARRAY);
+
+  for (i = 0; i < (size_t)RARRAY_LEN(msg_ents); i++) {
+    VALUE msg_ent = rb_ary_entry(msg_ents, i);
+    VALUE pos = rb_hash_aref(msg_ent, ID2SYM(rb_intern("pos")));
+    msgs[i] = msgs[NUM2INT(pos)];
+    rewrite_nesting(msg_ent, msgs[i], msgs, enums, arena);
+  }
+
+  for (i = 0; i < (size_t)RARRAY_LEN(enum_ents); i++) {
+    VALUE enum_pos = rb_ary_entry(enum_ents, i);
+    enums[i] = enums[NUM2INT(enum_pos)];
+  }
+
+  google_protobuf_FileDescriptorProto_resize_message_type(
+      file_proto, RARRAY_LEN(msg_ents), arena);
+  google_protobuf_FileDescriptorProto_resize_enum_type(
+      file_proto, RARRAY_LEN(enum_ents), arena);
 }
 
 // -----------------------------------------------------------------------------
@@ -92,16 +355,26 @@ static upb_enumdef* check_enum_notfrozen(const upb_enumdef* def) {
 
 // Global singleton DescriptorPool. The user is free to create others, but this
 // is used by generated code.
-VALUE generated_pool;
+VALUE generated_pool = Qnil;
 
 DEFINE_CLASS(DescriptorPool, "Google::Protobuf::DescriptorPool");
 
 void DescriptorPool_mark(void* _self) {
+  DescriptorPool* self = _self;
+  rb_gc_mark(self->def_to_descriptor);
 }
 
 void DescriptorPool_free(void* _self) {
   DescriptorPool* self = _self;
+
   upb_symtab_free(self->symtab);
+  upb_handlercache_free(self->fill_handler_cache);
+  upb_handlercache_free(self->pb_serialize_handler_cache);
+  upb_handlercache_free(self->json_serialize_handler_cache);
+  upb_handlercache_free(self->json_serialize_handler_preserve_cache);
+  upb_pbcodecache_free(self->fill_method_cache);
+  upb_json_codecache_free(self->json_fill_method_cache);
+
   xfree(self);
 }
 
@@ -113,15 +386,29 @@ void DescriptorPool_free(void* _self) {
  */
 VALUE DescriptorPool_alloc(VALUE klass) {
   DescriptorPool* self = ALLOC(DescriptorPool);
+  VALUE ret;
+
+  self->def_to_descriptor = Qnil;
+  ret = TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
+
+  self->def_to_descriptor = rb_hash_new();
   self->symtab = upb_symtab_new();
-  return TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
+  self->fill_handler_cache =
+      upb_handlercache_new(add_handlers_for_message, (void*)ret);
+  self->pb_serialize_handler_cache = upb_pb_encoder_newcache();
+  self->json_serialize_handler_cache = upb_json_printer_newcache(false);
+  self->json_serialize_handler_preserve_cache =
+      upb_json_printer_newcache(true);
+  self->fill_method_cache = upb_pbcodecache_new(self->fill_handler_cache);
+  self->json_fill_method_cache = upb_json_codecache_new();
+
+  return ret;
 }
 
 void DescriptorPool_register(VALUE module) {
   VALUE klass = rb_define_class_under(
       module, "DescriptorPool", rb_cObject);
   rb_define_alloc_func(klass, DescriptorPool_alloc);
-  rb_define_method(klass, "add", DescriptorPool_add, 1);
   rb_define_method(klass, "build", DescriptorPool_build, -1);
   rb_define_method(klass, "lookup", DescriptorPool_lookup, 1);
   rb_define_singleton_method(klass, "generated_pool",
@@ -133,44 +420,6 @@ void DescriptorPool_register(VALUE module) {
   generated_pool = rb_class_new_instance(0, NULL, klass);
 }
 
-static void add_descriptor_to_pool(DescriptorPool* self,
-                                   Descriptor* descriptor) {
-  CHECK_UPB(
-      upb_symtab_add(self->symtab, (upb_def**)&descriptor->msgdef, 1,
-                     NULL, &status),
-      "Adding Descriptor to DescriptorPool failed");
-}
-
-static void add_enumdesc_to_pool(DescriptorPool* self,
-                                 EnumDescriptor* enumdesc) {
-  CHECK_UPB(
-      upb_symtab_add(self->symtab, (upb_def**)&enumdesc->enumdef, 1,
-                     NULL, &status),
-      "Adding EnumDescriptor to DescriptorPool failed");
-}
-
-/*
- * call-seq:
- *     DescriptorPool.add(descriptor)
- *
- * Adds the given Descriptor or EnumDescriptor to this pool. All references to
- * other types in a Descriptor's fields must be resolvable within this pool or
- * an exception will be raised.
- */
-VALUE DescriptorPool_add(VALUE _self, VALUE def) {
-  DEFINE_SELF(DescriptorPool, self, _self);
-  VALUE def_klass = rb_obj_class(def);
-  if (def_klass == cDescriptor) {
-    add_descriptor_to_pool(self, ruby_to_Descriptor(def));
-  } else if (def_klass == cEnumDescriptor) {
-    add_enumdesc_to_pool(self, ruby_to_EnumDescriptor(def));
-  } else {
-    rb_raise(rb_eArgError,
-             "Second argument must be a Descriptor or EnumDescriptor.");
-  }
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     DescriptorPool.build(&block)
@@ -182,10 +431,10 @@ VALUE DescriptorPool_add(VALUE _self, VALUE def) {
  * idiomatic way to define new message and enum types.
  */
 VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
-  VALUE ctx = rb_class_new_instance(0, NULL, cBuilder);
+  VALUE ctx = rb_class_new_instance(1, &_self, cBuilder);
   VALUE block = rb_block_proc();
   rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  rb_funcall(ctx, rb_intern("finalize_to_pool"), 1, _self);
+  Builder_build(ctx);
   return Qnil;
 }
 
@@ -199,11 +448,20 @@ VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
 VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
   DEFINE_SELF(DescriptorPool, self, _self);
   const char* name_str = get_str(name);
-  const upb_def* def = upb_symtab_lookup(self->symtab, name_str);
-  if (!def) {
-    return Qnil;
+  const upb_msgdef* msgdef;
+  const upb_enumdef* enumdef;
+
+  msgdef = upb_symtab_lookupmsg(self->symtab, name_str);
+  if (msgdef) {
+    return get_msgdef_obj(_self, msgdef);
   }
-  return get_def_obj(def);
+
+  enumdef = upb_symtab_lookupenum(self->symtab, name_str);
+  if (enumdef) {
+    return get_enumdef_obj(_self, enumdef);
+  }
+
+  return Qnil;
 }
 
 /*
@@ -228,36 +486,17 @@ DEFINE_CLASS(Descriptor, "Google::Protobuf::Descriptor");
 void Descriptor_mark(void* _self) {
   Descriptor* self = _self;
   rb_gc_mark(self->klass);
+  rb_gc_mark(self->descriptor_pool);
+  if (self->layout && self->layout->empty_template) {
+    layout_mark(self->layout, self->layout->empty_template);
+  }
 }
 
 void Descriptor_free(void* _self) {
   Descriptor* self = _self;
-  upb_msgdef_unref(self->msgdef, &self->msgdef);
   if (self->layout) {
     free_layout(self->layout);
   }
-  if (self->fill_handlers) {
-    upb_handlers_unref(self->fill_handlers, &self->fill_handlers);
-  }
-  if (self->fill_method) {
-    upb_pbdecodermethod_unref(self->fill_method, &self->fill_method);
-  }
-  if (self->json_fill_method) {
-    upb_json_parsermethod_unref(self->json_fill_method,
-                                &self->json_fill_method);
-  }
-  if (self->pb_serialize_handlers) {
-    upb_handlers_unref(self->pb_serialize_handlers,
-                       &self->pb_serialize_handlers);
-  }
-  if (self->json_serialize_handlers) {
-    upb_handlers_unref(self->json_serialize_handlers,
-                       &self->json_serialize_handlers);
-  }
-  if (self->json_serialize_handlers_preserve) {
-    upb_handlers_unref(self->json_serialize_handlers_preserve,
-                       &self->json_serialize_handlers_preserve);
-  }
   xfree(self);
 }
 
@@ -273,15 +512,10 @@ void Descriptor_free(void* _self) {
 VALUE Descriptor_alloc(VALUE klass) {
   Descriptor* self = ALLOC(Descriptor);
   VALUE ret = TypedData_Wrap_Struct(klass, &_Descriptor_type, self);
-  self->msgdef = upb_msgdef_new(&self->msgdef);
+  self->msgdef = NULL;
   self->klass = Qnil;
+  self->descriptor_pool = Qnil;
   self->layout = NULL;
-  self->fill_handlers = NULL;
-  self->fill_method = NULL;
-  self->json_fill_method = NULL;
-  self->pb_serialize_handlers = NULL;
-  self->json_serialize_handlers = NULL;
-  self->json_serialize_handlers_preserve = NULL;
   return ret;
 }
 
@@ -289,16 +523,13 @@ void Descriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(
       module, "Descriptor", rb_cObject);
   rb_define_alloc_func(klass, Descriptor_alloc);
-  rb_define_method(klass, "initialize", Descriptor_initialize, 1);
+  rb_define_method(klass, "initialize", Descriptor_initialize, 3);
   rb_define_method(klass, "each", Descriptor_each, 0);
   rb_define_method(klass, "lookup", Descriptor_lookup, 1);
-  rb_define_method(klass, "add_field", Descriptor_add_field, 1);
-  rb_define_method(klass, "add_oneof", Descriptor_add_oneof, 1);
   rb_define_method(klass, "each_oneof", Descriptor_each_oneof, 0);
   rb_define_method(klass, "lookup_oneof", Descriptor_lookup_oneof, 1);
   rb_define_method(klass, "msgclass", Descriptor_msgclass, 0);
   rb_define_method(klass, "name", Descriptor_name, 0);
-  rb_define_method(klass, "name=", Descriptor_name_set, 1);
   rb_define_method(klass, "file_descriptor", Descriptor_file_descriptor, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cDescriptor);
@@ -307,19 +538,21 @@ void Descriptor_register(VALUE module) {
 
 /*
  * call-seq:
- *    Descriptor.new(file_descriptor)
+ *    Descriptor.new(c_only_cookie, ptr) => Descriptor
  *
- * Initializes a new descriptor and assigns a file descriptor to it.
+ * Creates a descriptor wrapper object.  May only be called from C.
  */
-VALUE Descriptor_initialize(VALUE _self, VALUE file_descriptor_rb) {
+VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
+                            VALUE descriptor_pool, VALUE ptr) {
   DEFINE_SELF(Descriptor, self, _self);
 
-  FileDescriptor* file_descriptor = ruby_to_FileDescriptor(file_descriptor_rb);
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
 
-  CHECK_UPB(
-        upb_filedef_addmsg(file_descriptor->filedef, self->msgdef, NULL, &status),
-        "Failed to associate message to file descriptor.");
-  add_def_obj(file_descriptor->filedef, file_descriptor_rb);
+  self->descriptor_pool = descriptor_pool;
+  self->msgdef = (const upb_msgdef*)NUM2ULL(ptr);
 
   return Qnil;
 }
@@ -332,7 +565,7 @@ VALUE Descriptor_initialize(VALUE _self, VALUE file_descriptor_rb) {
  */
 VALUE Descriptor_file_descriptor(VALUE _self) {
   DEFINE_SELF(Descriptor, self, _self);
-  return get_def_obj(upb_def_file(self->msgdef));
+  return get_filedef_obj(self->descriptor_pool, upb_msgdef_file(self->msgdef));
 }
 
 /*
@@ -347,23 +580,6 @@ VALUE Descriptor_name(VALUE _self) {
   return rb_str_maybe_null(upb_msgdef_fullname(self->msgdef));
 }
 
-/*
- * call-seq:
- *    Descriptor.name = name
- *
- * Assigns a name to this message type. The descriptor must not have been added
- * to a pool yet.
- */
-VALUE Descriptor_name_set(VALUE _self, VALUE str) {
-  DEFINE_SELF(Descriptor, self, _self);
-  upb_msgdef* mut_def = check_msg_notfrozen(self->msgdef);
-  const char* name = get_str(str);
-  CHECK_UPB(
-      upb_msgdef_setfullname(mut_def, name, &status),
-      "Error setting Descriptor name");
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     Descriptor.each(&block)
@@ -378,7 +594,7 @@ VALUE Descriptor_each(VALUE _self) {
        !upb_msg_field_done(&it);
        upb_msg_field_next(&it)) {
     const upb_fielddef* field = upb_msg_iter_field(&it);
-    VALUE obj = get_def_obj(field);
+    VALUE obj = get_fielddef_obj(self->descriptor_pool, field);
     rb_yield(obj);
   }
   return Qnil;
@@ -398,51 +614,7 @@ VALUE Descriptor_lookup(VALUE _self, VALUE name) {
   if (field == NULL) {
     return Qnil;
   }
-  return get_def_obj(field);
-}
-
-/*
- * call-seq:
- *     Descriptor.add_field(field) => nil
- *
- * Adds the given FieldDescriptor to this message type. This descriptor must not
- * have been added to a pool yet. Raises an exception if a field with the same
- * name or number already exists. Sub-type references (e.g. for fields of type
- * message) are not resolved at this point.
- */
-VALUE Descriptor_add_field(VALUE _self, VALUE obj) {
-  DEFINE_SELF(Descriptor, self, _self);
-  upb_msgdef* mut_def = check_msg_notfrozen(self->msgdef);
-  FieldDescriptor* def = ruby_to_FieldDescriptor(obj);
-  upb_fielddef* mut_field_def = check_field_notfrozen(def->fielddef);
-  CHECK_UPB(
-      upb_msgdef_addfield(mut_def, mut_field_def, NULL, &status),
-      "Adding field to Descriptor failed");
-  add_def_obj(def->fielddef, obj);
-  return Qnil;
-}
-
-/*
- * call-seq:
- *     Descriptor.add_oneof(oneof) => nil
- *
- * Adds the given OneofDescriptor to this message type. This descriptor must not
- * have been added to a pool yet. Raises an exception if a oneof with the same
- * name already exists, or if any of the oneof's fields' names or numbers
- * conflict with an existing field in this message type. All fields in the oneof
- * are added to the message descriptor. Sub-type references (e.g. for fields of
- * type message) are not resolved at this point.
- */
-VALUE Descriptor_add_oneof(VALUE _self, VALUE obj) {
-  DEFINE_SELF(Descriptor, self, _self);
-  upb_msgdef* mut_def = check_msg_notfrozen(self->msgdef);
-  OneofDescriptor* def = ruby_to_OneofDescriptor(obj);
-  upb_oneofdef* mut_oneof_def = check_oneof_notfrozen(def->oneofdef);
-  CHECK_UPB(
-      upb_msgdef_addoneof(mut_def, mut_oneof_def, NULL, &status),
-      "Adding oneof to Descriptor failed");
-  add_def_obj(def->oneofdef, obj);
-  return Qnil;
+  return get_fielddef_obj(self->descriptor_pool, field);
 }
 
 /*
@@ -460,7 +632,7 @@ VALUE Descriptor_each_oneof(VALUE _self) {
        !upb_msg_oneof_done(&it);
        upb_msg_oneof_next(&it)) {
     const upb_oneofdef* oneof = upb_msg_iter_oneof(&it);
-    VALUE obj = get_def_obj(oneof);
+    VALUE obj = get_oneofdef_obj(self->descriptor_pool, oneof);
     rb_yield(obj);
   }
   return Qnil;
@@ -480,24 +652,19 @@ VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
   if (oneof == NULL) {
     return Qnil;
   }
-  return get_def_obj(oneof);
+  return get_oneofdef_obj(self->descriptor_pool, oneof);
 }
 
 /*
  * call-seq:
  *     Descriptor.msgclass => message_klass
  *
- * Returns the Ruby class created for this message type. Valid only once the
- * message type has been added to a pool.
+ * Returns the Ruby class created for this message type.
  */
 VALUE Descriptor_msgclass(VALUE _self) {
   DEFINE_SELF(Descriptor, self, _self);
-  if (!upb_def_isfrozen((const upb_def*)self->msgdef)) {
-    rb_raise(rb_eRuntimeError,
-             "Cannot fetch message class from a Descriptor not yet in a pool.");
-  }
   if (self->klass == Qnil) {
-    self->klass = build_class_from_descriptor(self);
+    self->klass = build_class_from_descriptor(_self);
   }
   return self->klass;
 }
@@ -509,12 +676,20 @@ VALUE Descriptor_msgclass(VALUE _self) {
 DEFINE_CLASS(FileDescriptor, "Google::Protobuf::FileDescriptor");
 
 void FileDescriptor_mark(void* _self) {
+  FileDescriptor* self = _self;
+  rb_gc_mark(self->descriptor_pool);
 }
 
 void FileDescriptor_free(void* _self) {
-  FileDescriptor* self = _self;
-  upb_filedef_unref(self->filedef, &self->filedef);
-  xfree(self);
+  xfree(_self);
+}
+
+VALUE FileDescriptor_alloc(VALUE klass) {
+  FileDescriptor* self = ALLOC(FileDescriptor);
+  VALUE ret = TypedData_Wrap_Struct(klass, &_FileDescriptor_type, self);
+  self->descriptor_pool = Qnil;
+  self->filedef = NULL;
+  return ret;
 }
 
 /*
@@ -524,64 +699,32 @@ void FileDescriptor_free(void* _self) {
  * Returns a new file descriptor. The syntax must be set before it's passed
  * to a builder.
  */
-VALUE FileDescriptor_alloc(VALUE klass) {
-  FileDescriptor* self = ALLOC(FileDescriptor);
-  VALUE ret = TypedData_Wrap_Struct(klass, &_FileDescriptor_type, self);
-  upb_filedef* filedef = upb_filedef_new(&self->filedef);
-  self->filedef = filedef;
-  return ret;
+VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
+                                VALUE descriptor_pool, VALUE ptr) {
+  DEFINE_SELF(FileDescriptor, self, _self);
+
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  self->descriptor_pool = descriptor_pool;
+  self->filedef = (const upb_filedef*)NUM2ULL(ptr);
+
+  return Qnil;
 }
 
 void FileDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(
       module, "FileDescriptor", rb_cObject);
   rb_define_alloc_func(klass, FileDescriptor_alloc);
-  rb_define_method(klass, "initialize", FileDescriptor_initialize, -1);
+  rb_define_method(klass, "initialize", FileDescriptor_initialize, 3);
   rb_define_method(klass, "name", FileDescriptor_name, 0);
   rb_define_method(klass, "syntax", FileDescriptor_syntax, 0);
-  rb_define_method(klass, "syntax=", FileDescriptor_syntax_set, 1);
   rb_gc_register_address(&cFileDescriptor);
   cFileDescriptor = klass;
 }
 
-/*
- * call-seq:
- *     FileDescriptor.new(name, options = nil) => file
- *
- * Initializes a new file descriptor with the given file name.
- * Also accepts an optional "options" hash, specifying other optional
- * metadata about the file. The options hash currently accepts the following
- *   * "syntax": :proto2 or :proto3 (default: :proto3)
- */
-VALUE FileDescriptor_initialize(int argc, VALUE* argv, VALUE _self) {
-  DEFINE_SELF(FileDescriptor, self, _self);
-
-  VALUE name_rb;
-  VALUE options = Qnil;
-  rb_scan_args(argc, argv, "11", &name_rb, &options);
-
-  if (name_rb != Qnil) {
-    Check_Type(name_rb, T_STRING);
-    const char* name = get_str(name_rb);
-    CHECK_UPB(upb_filedef_setname(self->filedef, name, &status),
-	      "Error setting file name");
-  }
-
-  // Default syntax is proto3.
-  VALUE syntax = ID2SYM(rb_intern("proto3"));
-  if (options != Qnil) {
-    Check_Type(options, T_HASH);
-
-    if (rb_funcall(options, rb_intern("key?"), 1,
-		   ID2SYM(rb_intern("syntax"))) == Qtrue) {
-      syntax = rb_hash_lookup(options, ID2SYM(rb_intern("syntax")));
-    }
-  }
-  FileDescriptor_syntax_set(_self, syntax);
-
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     FileDescriptor.name => name
@@ -613,31 +756,6 @@ VALUE FileDescriptor_syntax(VALUE _self) {
   }
 }
 
-/*
- * call-seq:
- *     FileDescriptor.syntax = version
- *
- * Sets this file descriptor's syntax, can be :proto3 or :proto2.
- */
-VALUE FileDescriptor_syntax_set(VALUE _self, VALUE syntax_rb) {
-  DEFINE_SELF(FileDescriptor, self, _self);
-  Check_Type(syntax_rb, T_SYMBOL);
-
-  upb_syntax_t syntax;
-  if (SYM2ID(syntax_rb) == rb_intern("proto3")) {
-    syntax = UPB_SYNTAX_PROTO3;
-  } else if (SYM2ID(syntax_rb) == rb_intern("proto2")) {
-    syntax = UPB_SYNTAX_PROTO2;
-  } else {
-    rb_raise(rb_eArgError, "Expected :proto3 or :proto3, received '%s'",
-	     rb_id2name(SYM2ID(syntax_rb)));
-  }
-
-  CHECK_UPB(upb_filedef_setsyntax(self->filedef, syntax, &status),
-          "Error setting file syntax for proto");
-  return Qnil;
-}
-
 // -----------------------------------------------------------------------------
 // FieldDescriptor.
 // -----------------------------------------------------------------------------
@@ -645,12 +763,12 @@ VALUE FileDescriptor_syntax_set(VALUE _self, VALUE syntax_rb) {
 DEFINE_CLASS(FieldDescriptor, "Google::Protobuf::FieldDescriptor");
 
 void FieldDescriptor_mark(void* _self) {
+  FieldDescriptor* self = _self;
+  rb_gc_mark(self->descriptor_pool);
 }
 
 void FieldDescriptor_free(void* _self) {
-  FieldDescriptor* self = _self;
-  upb_fielddef_unref(self->fielddef, &self->fielddef);
-  xfree(self);
+  xfree(_self);
 }
 
 /*
@@ -663,9 +781,7 @@ void FieldDescriptor_free(void* _self) {
 VALUE FieldDescriptor_alloc(VALUE klass) {
   FieldDescriptor* self = ALLOC(FieldDescriptor);
   VALUE ret = TypedData_Wrap_Struct(klass, &_FieldDescriptor_type, self);
-  upb_fielddef* fielddef = upb_fielddef_new(&self->fielddef);
-  upb_fielddef_setpacked(fielddef, false);
-  self->fielddef = fielddef;
+  self->fielddef = NULL;
   return ret;
 }
 
@@ -673,18 +789,13 @@ void FieldDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(
       module, "FieldDescriptor", rb_cObject);
   rb_define_alloc_func(klass, FieldDescriptor_alloc);
+  rb_define_method(klass, "initialize", FieldDescriptor_initialize, 3);
   rb_define_method(klass, "name", FieldDescriptor_name, 0);
-  rb_define_method(klass, "name=", FieldDescriptor_name_set, 1);
   rb_define_method(klass, "type", FieldDescriptor_type, 0);
-  rb_define_method(klass, "type=", FieldDescriptor_type_set, 1);
   rb_define_method(klass, "default", FieldDescriptor_default, 0);
-  rb_define_method(klass, "default=", FieldDescriptor_default_set, 1);
   rb_define_method(klass, "label", FieldDescriptor_label, 0);
-  rb_define_method(klass, "label=", FieldDescriptor_label_set, 1);
   rb_define_method(klass, "number", FieldDescriptor_number, 0);
-  rb_define_method(klass, "number=", FieldDescriptor_number_set, 1);
   rb_define_method(klass, "submsg_name", FieldDescriptor_submsg_name, 0);
-  rb_define_method(klass, "submsg_name=", FieldDescriptor_submsg_name_set, 1);
   rb_define_method(klass, "subtype", FieldDescriptor_subtype, 0);
   rb_define_method(klass, "has?", FieldDescriptor_has, 1);
   rb_define_method(klass, "clear", FieldDescriptor_clear, 1);
@@ -696,29 +807,34 @@ void FieldDescriptor_register(VALUE module) {
 
 /*
  * call-seq:
- *     FieldDescriptor.name => name
+ *    EnumDescriptor.new(c_only_cookie, pool, ptr) => EnumDescriptor
  *
- * Returns the name of this field.
+ * Creates a descriptor wrapper object.  May only be called from C.
  */
-VALUE FieldDescriptor_name(VALUE _self) {
+VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
+                                 VALUE descriptor_pool, VALUE ptr) {
   DEFINE_SELF(FieldDescriptor, self, _self);
-  return rb_str_maybe_null(upb_fielddef_name(self->fielddef));
+
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  self->descriptor_pool = descriptor_pool;
+  self->fielddef = (const upb_fielddef*)NUM2ULL(ptr);
+
+  return Qnil;
 }
 
 /*
  * call-seq:
- *     FieldDescriptor.name = name
+ *     FieldDescriptor.name => name
  *
- * Sets the name of this field. Cannot be called once the containing message
- * type, if any, is added to a pool.
+ * Returns the name of this field.
  */
-VALUE FieldDescriptor_name_set(VALUE _self, VALUE str) {
+VALUE FieldDescriptor_name(VALUE _self) {
   DEFINE_SELF(FieldDescriptor, self, _self);
-  upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
-  const char* name = get_str(str);
-  CHECK_UPB(upb_fielddef_setname(mut_def, name, &status),
-            "Error setting FieldDescriptor name");
-  return Qnil;
+  return rb_str_maybe_null(upb_fielddef_name(self->fielddef));
 }
 
 upb_fieldtype_t ruby_to_fieldtype(VALUE type) {
@@ -831,6 +947,29 @@ VALUE descriptortype_to_ruby(upb_descriptortype_t type) {
   return Qnil;
 }
 
+VALUE ruby_to_label(VALUE label) {
+  upb_label_t upb_label;
+  bool converted = false;
+
+#define CONVERT(upb, ruby)                                           \
+  if (SYM2ID(label) == rb_intern( # ruby )) {                        \
+    upb_label = UPB_LABEL_ ## upb;                                   \
+    converted = true;                                                \
+  }
+
+  CONVERT(OPTIONAL, optional);
+  CONVERT(REQUIRED, required);
+  CONVERT(REPEATED, repeated);
+
+#undef CONVERT
+
+  if (!converted) {
+    rb_raise(rb_eArgError, "Unknown field label.");
+  }
+
+  return upb_label;
+}
+
 /*
  * call-seq:
  *     FieldDescriptor.type => type
@@ -843,26 +982,9 @@ VALUE descriptortype_to_ruby(upb_descriptortype_t type) {
  */
 VALUE FieldDescriptor_type(VALUE _self) {
   DEFINE_SELF(FieldDescriptor, self, _self);
-  if (!upb_fielddef_typeisset(self->fielddef)) {
-    return Qnil;
-  }
   return descriptortype_to_ruby(upb_fielddef_descriptortype(self->fielddef));
 }
 
-/*
- * call-seq:
- *     FieldDescriptor.type = type
- *
- * Sets this field's type. Cannot be called if field is part of a message type
- * already in a pool.
- */
-VALUE FieldDescriptor_type_set(VALUE _self, VALUE type) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
-  upb_fielddef_setdescriptortype(mut_def, ruby_to_descriptortype(type));
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     FieldDescriptor.default => default
@@ -874,60 +996,6 @@ VALUE FieldDescriptor_default(VALUE _self) {
   return layout_get_default(self->fielddef);
 }
 
-/*
- * call-seq:
- *     FieldDescriptor.default = default
- *
- * Sets this field's default value. Raises an exception when calling with
- * proto syntax 3.
- */
-VALUE FieldDescriptor_default_set(VALUE _self, VALUE default_value) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
-
-  switch (upb_fielddef_type(mut_def)) {
-    case UPB_TYPE_FLOAT:
-      upb_fielddef_setdefaultfloat(mut_def, NUM2DBL(default_value));
-      break;
-    case UPB_TYPE_DOUBLE:
-      upb_fielddef_setdefaultdouble(mut_def, NUM2DBL(default_value));
-      break;
-    case UPB_TYPE_BOOL:
-      if (!RB_TYPE_P(default_value, T_TRUE) &&
-	  !RB_TYPE_P(default_value, T_FALSE) &&
-	  !RB_TYPE_P(default_value, T_NIL)) {
-        rb_raise(cTypeError, "Expected boolean for default value.");
-      }
-
-      upb_fielddef_setdefaultbool(mut_def, RTEST(default_value));
-      break;
-    case UPB_TYPE_ENUM:
-    case UPB_TYPE_INT32:
-      upb_fielddef_setdefaultint32(mut_def, NUM2INT(default_value));
-      break;
-    case UPB_TYPE_INT64:
-      upb_fielddef_setdefaultint64(mut_def, NUM2INT(default_value));
-      break;
-    case UPB_TYPE_UINT32:
-      upb_fielddef_setdefaultuint32(mut_def, NUM2UINT(default_value));
-      break;
-    case UPB_TYPE_UINT64:
-      upb_fielddef_setdefaultuint64(mut_def, NUM2UINT(default_value));
-      break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-      CHECK_UPB(upb_fielddef_setdefaultcstr(mut_def, StringValuePtr(default_value),
-					    &status),
-                "Error setting default string");
-      break;
-    default:
-      rb_raise(rb_eArgError, "Defaults not supported on field %s.%s",
-	       upb_fielddef_fullname(mut_def), upb_fielddef_name(mut_def));
-  }
-
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     FieldDescriptor.label => label
@@ -953,44 +1021,6 @@ VALUE FieldDescriptor_label(VALUE _self) {
   return Qnil;
 }
 
-/*
- * call-seq:
- *     FieldDescriptor.label = label
- *
- * Sets the label on this field. Cannot be called if field is part of a message
- * type already in a pool.
- */
-VALUE FieldDescriptor_label_set(VALUE _self, VALUE label) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
-  upb_label_t upb_label = -1;
-  bool converted = false;
-
-  if (TYPE(label) != T_SYMBOL) {
-    rb_raise(rb_eArgError, "Expected symbol for field label.");
-  }
-
-#define CONVERT(upb, ruby)                                           \
-  if (SYM2ID(label) == rb_intern( # ruby )) {                        \
-    upb_label = UPB_LABEL_ ## upb;                                   \
-    converted = true;                                                \
-  }
-
-  CONVERT(OPTIONAL, optional);
-  CONVERT(REQUIRED, required);
-  CONVERT(REPEATED, repeated);
-
-#undef CONVERT
-
-  if (!converted) {
-    rb_raise(rb_eArgError, "Unknown field label.");
-  }
-
-  upb_fielddef_setlabel(mut_def, upb_label);
-
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     FieldDescriptor.number => number
@@ -1002,21 +1032,6 @@ VALUE FieldDescriptor_number(VALUE _self) {
   return INT2NUM(upb_fielddef_number(self->fielddef));
 }
 
-/*
- * call-seq:
- *     FieldDescriptor.number = number
- *
- * Sets the tag number for this field. Cannot be called if field is part of a
- * message type already in a pool.
- */
-VALUE FieldDescriptor_number_set(VALUE _self, VALUE number) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
-  CHECK_UPB(upb_fielddef_setnumber(mut_def, NUM2INT(number), &status),
-            "Error setting field number");
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     FieldDescriptor.submsg_name => submsg_name
@@ -1028,32 +1043,16 @@ VALUE FieldDescriptor_number_set(VALUE _self, VALUE number) {
  */
 VALUE FieldDescriptor_submsg_name(VALUE _self) {
   DEFINE_SELF(FieldDescriptor, self, _self);
-  if (!upb_fielddef_hassubdef(self->fielddef)) {
-    return Qnil;
-  }
-  return rb_str_maybe_null(upb_fielddef_subdefname(self->fielddef));
-}
-
-/*
- * call-seq:
- *     FieldDescriptor.submsg_name = submsg_name
- *
- * Sets the name of the message or enum type corresponding to this field, if it
- * is a message or enum field (respectively). This type name will be resolved
- * within the context of the pool to which the containing message type is added.
- * Cannot be called on field that are not of message or enum type, or on fields
- * that are part of a message type already added to a pool.
- */
-VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
-  const char* str = get_str(value);
-  if (!upb_fielddef_hassubdef(self->fielddef)) {
-    rb_raise(cTypeError, "FieldDescriptor does not have subdef.");
+  switch (upb_fielddef_type(self->fielddef)) {
+    case UPB_TYPE_ENUM:
+      return rb_str_new2(
+          upb_enumdef_fullname(upb_fielddef_enumsubdef(self->fielddef)));
+    case UPB_TYPE_MESSAGE:
+      return rb_str_new2(
+          upb_msgdef_fullname(upb_fielddef_msgsubdef(self->fielddef)));
+    default:
+      return Qnil;
   }
-  CHECK_UPB(upb_fielddef_setsubdefname(mut_def, str, &status),
-            "Error setting submessage name");
-  return Qnil;
 }
 
 /*
@@ -1067,16 +1066,16 @@ VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value) {
  */
 VALUE FieldDescriptor_subtype(VALUE _self) {
   DEFINE_SELF(FieldDescriptor, self, _self);
-  const upb_def* def;
-
-  if (!upb_fielddef_hassubdef(self->fielddef)) {
-    return Qnil;
-  }
-  def = upb_fielddef_subdef(self->fielddef);
-  if (def == NULL) {
-    return Qnil;
+  switch (upb_fielddef_type(self->fielddef)) {
+    case UPB_TYPE_ENUM:
+      return get_enumdef_obj(self->descriptor_pool,
+                             upb_fielddef_enumsubdef(self->fielddef));
+    case UPB_TYPE_MESSAGE:
+      return get_msgdef_obj(self->descriptor_pool,
+                            upb_fielddef_msgsubdef(self->fielddef));
+    default:
+      return Qnil;
   }
-  return get_def_obj(def);
 }
 
 /*
@@ -1160,12 +1159,12 @@ VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
 DEFINE_CLASS(OneofDescriptor, "Google::Protobuf::OneofDescriptor");
 
 void OneofDescriptor_mark(void* _self) {
+  OneofDescriptor* self = _self;
+  rb_gc_mark(self->descriptor_pool);
 }
 
 void OneofDescriptor_free(void* _self) {
-  OneofDescriptor* self = _self;
-  upb_oneofdef_unref(self->oneofdef, &self->oneofdef);
-  xfree(self);
+  xfree(_self);
 }
 
 /*
@@ -1178,7 +1177,8 @@ void OneofDescriptor_free(void* _self) {
 VALUE OneofDescriptor_alloc(VALUE klass) {
   OneofDescriptor* self = ALLOC(OneofDescriptor);
   VALUE ret = TypedData_Wrap_Struct(klass, &_OneofDescriptor_type, self);
-  self->oneofdef = upb_oneofdef_new(&self->oneofdef);
+  self->oneofdef = NULL;
+  self->descriptor_pool = Qnil;
   return ret;
 }
 
@@ -1186,9 +1186,8 @@ void OneofDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(
       module, "OneofDescriptor", rb_cObject);
   rb_define_alloc_func(klass, OneofDescriptor_alloc);
+  rb_define_method(klass, "initialize", OneofDescriptor_initialize, 3);
   rb_define_method(klass, "name", OneofDescriptor_name, 0);
-  rb_define_method(klass, "name=", OneofDescriptor_name_set, 1);
-  rb_define_method(klass, "add_field", OneofDescriptor_add_field, 1);
   rb_define_method(klass, "each", OneofDescriptor_each, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cOneofDescriptor);
@@ -1197,55 +1196,34 @@ void OneofDescriptor_register(VALUE module) {
 
 /*
  * call-seq:
- *     OneofDescriptor.name => name
+ *    OneofDescriptor.new(c_only_cookie, pool, ptr) => OneofDescriptor
  *
- * Returns the name of this oneof.
+ * Creates a descriptor wrapper object.  May only be called from C.
  */
-VALUE OneofDescriptor_name(VALUE _self) {
+VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
+                                 VALUE descriptor_pool, VALUE ptr) {
   DEFINE_SELF(OneofDescriptor, self, _self);
-  return rb_str_maybe_null(upb_oneofdef_name(self->oneofdef));
-}
 
-/*
- * call-seq:
- *     OneofDescriptor.name = name
- *
- * Sets a new name for this oneof. The oneof must not have been added to a
- * message descriptor yet.
- */
-VALUE OneofDescriptor_name_set(VALUE _self, VALUE value) {
-  DEFINE_SELF(OneofDescriptor, self, _self);
-  upb_oneofdef* mut_def = check_oneof_notfrozen(self->oneofdef);
-  const char* str = get_str(value);
-  CHECK_UPB(upb_oneofdef_setname(mut_def, str, &status),
-            "Error setting oneof name");
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  self->descriptor_pool = descriptor_pool;
+  self->oneofdef = (const upb_oneofdef*)NUM2ULL(ptr);
+
   return Qnil;
 }
 
 /*
  * call-seq:
- *     OneofDescriptor.add_field(field) => nil
- *
- * Adds a field to this oneof. The field may have been added to this oneof in
- * the past, or the message to which this oneof belongs (if any), but may not
- * have already been added to any other oneof or message. Otherwise, an
- * exception is raised.
+ *     OneofDescriptor.name => name
  *
- * All fields added to the oneof via this method will be automatically added to
- * the message to which this oneof belongs, if it belongs to one currently, or
- * else will be added to any message to which the oneof is later added at the
- * time that it is added.
+ * Returns the name of this oneof.
  */
-VALUE OneofDescriptor_add_field(VALUE _self, VALUE obj) {
+VALUE OneofDescriptor_name(VALUE _self) {
   DEFINE_SELF(OneofDescriptor, self, _self);
-  upb_oneofdef* mut_def = check_oneof_notfrozen(self->oneofdef);
-  FieldDescriptor* def = ruby_to_FieldDescriptor(obj);
-  upb_fielddef* mut_field_def = check_field_notfrozen(def->fielddef);
-  CHECK_UPB(
-      upb_oneofdef_addfield(mut_def, mut_field_def, NULL, &status),
-      "Adding field to OneofDescriptor failed");
-  add_def_obj(def->fielddef, obj);
-  return Qnil;
+  return rb_str_maybe_null(upb_oneofdef_name(self->oneofdef));
 }
 
 /*
@@ -1261,7 +1239,7 @@ VALUE OneofDescriptor_each(VALUE _self, VALUE field) {
        !upb_oneof_done(&it);
        upb_oneof_next(&it)) {
     const upb_fielddef* f = upb_oneof_iter_field(&it);
-    VALUE obj = get_def_obj(f);
+    VALUE obj = get_fielddef_obj(self->descriptor_pool, f);
     rb_yield(obj);
   }
   return Qnil;
@@ -1276,38 +1254,49 @@ DEFINE_CLASS(EnumDescriptor, "Google::Protobuf::EnumDescriptor");
 void EnumDescriptor_mark(void* _self) {
   EnumDescriptor* self = _self;
   rb_gc_mark(self->module);
+  rb_gc_mark(self->descriptor_pool);
 }
 
 void EnumDescriptor_free(void* _self) {
-  EnumDescriptor* self = _self;
-  upb_enumdef_unref(self->enumdef, &self->enumdef);
-  xfree(self);
+  xfree(_self);
 }
 
-/*
- * call-seq:
- *     EnumDescriptor.new => enum_descriptor
- *
- * Creates a new, empty, enum descriptor. Must be added to a pool before the
- * enum type can be used. The enum type may only be modified prior to adding to
- * a pool.
- */
 VALUE EnumDescriptor_alloc(VALUE klass) {
   EnumDescriptor* self = ALLOC(EnumDescriptor);
   VALUE ret = TypedData_Wrap_Struct(klass, &_EnumDescriptor_type, self);
-  self->enumdef = upb_enumdef_new(&self->enumdef);
+  self->enumdef = NULL;
   self->module = Qnil;
+  self->descriptor_pool = Qnil;
   return ret;
 }
 
+/*
+ * call-seq:
+ *    EnumDescriptor.new(c_only_cookie, ptr) => EnumDescriptor
+ *
+ * Creates a descriptor wrapper object.  May only be called from C.
+ */
+VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
+                                VALUE descriptor_pool, VALUE ptr) {
+  DEFINE_SELF(EnumDescriptor, self, _self);
+
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  self->descriptor_pool = descriptor_pool;
+  self->enumdef = (const upb_enumdef*)NUM2ULL(ptr);
+
+  return Qnil;
+}
+
 void EnumDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(
       module, "EnumDescriptor", rb_cObject);
   rb_define_alloc_func(klass, EnumDescriptor_alloc);
-  rb_define_method(klass, "initialize", EnumDescriptor_initialize, 1);
+  rb_define_method(klass, "initialize", EnumDescriptor_initialize, 3);
   rb_define_method(klass, "name", EnumDescriptor_name, 0);
-  rb_define_method(klass, "name=", EnumDescriptor_name_set, 1);
-  rb_define_method(klass, "add_value", EnumDescriptor_add_value, 2);
   rb_define_method(klass, "lookup_name", EnumDescriptor_lookup_name, 1);
   rb_define_method(klass, "lookup_value", EnumDescriptor_lookup_value, 1);
   rb_define_method(klass, "each", EnumDescriptor_each, 0);
@@ -1320,31 +1309,14 @@ void EnumDescriptor_register(VALUE module) {
 
 /*
  * call-seq:
- *    Descriptor.new(file_descriptor)
- *
- * Initializes a new descriptor and assigns a file descriptor to it.
- */
-VALUE EnumDescriptor_initialize(VALUE _self, VALUE file_descriptor_rb) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
-  FileDescriptor* file_descriptor = ruby_to_FileDescriptor(file_descriptor_rb);
-  CHECK_UPB(
-        upb_filedef_addenum(file_descriptor->filedef, self->enumdef,
-			    NULL, &status),
-        "Failed to associate enum to file descriptor.");
-  add_def_obj(file_descriptor->filedef, file_descriptor_rb);
-
-  return Qnil;
-}
-
-/*
- * call-seq:
- *    Descriptor.file_descriptor
+ *    EnumDescriptor.file_descriptor
  *
  * Returns the FileDescriptor object this enum belongs to.
  */
 VALUE EnumDescriptor_file_descriptor(VALUE _self) {
   DEFINE_SELF(EnumDescriptor, self, _self);
-  return get_def_obj(upb_def_file(self->enumdef));
+  return get_filedef_obj(self->descriptor_pool,
+                         upb_enumdef_file(self->enumdef));
 }
 
 /*
@@ -1358,40 +1330,6 @@ VALUE EnumDescriptor_name(VALUE _self) {
   return rb_str_maybe_null(upb_enumdef_fullname(self->enumdef));
 }
 
-/*
- * call-seq:
- *     EnumDescriptor.name = name
- *
- * Sets the name of this enum type. Cannot be called if the enum type has
- * already been added to a pool.
- */
-VALUE EnumDescriptor_name_set(VALUE _self, VALUE str) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
-  upb_enumdef* mut_def = check_enum_notfrozen(self->enumdef);
-  const char* name = get_str(str);
-  CHECK_UPB(upb_enumdef_setfullname(mut_def, name, &status),
-            "Error setting EnumDescriptor name");
-  return Qnil;
-}
-
-/*
- * call-seq:
- *     EnumDescriptor.add_value(key, value)
- *
- * Adds a new key => value mapping to this enum type. Key must be given as a
- * Ruby symbol. Cannot be called if the enum type has already been added to a
- * pool. Will raise an exception if the key or value is already in use.
- */
-VALUE EnumDescriptor_add_value(VALUE _self, VALUE name, VALUE number) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
-  upb_enumdef* mut_def = check_enum_notfrozen(self->enumdef);
-  const char* name_str = rb_id2name(SYM2ID(name));
-  int32_t val = NUM2INT(number);
-  CHECK_UPB(upb_enumdef_addval(mut_def, name_str, val, &status),
-            "Error adding value to enum");
-  return Qnil;
-}
-
 /*
  * call-seq:
  *     EnumDescriptor.lookup_name(name) => value
@@ -1454,18 +1392,12 @@ VALUE EnumDescriptor_each(VALUE _self) {
  * call-seq:
  *     EnumDescriptor.enummodule => module
  *
- * Returns the Ruby module corresponding to this enum type. Cannot be called
- * until the enum descriptor has been added to a pool.
+ * Returns the Ruby module corresponding to this enum type.
  */
 VALUE EnumDescriptor_enummodule(VALUE _self) {
   DEFINE_SELF(EnumDescriptor, self, _self);
-  if (!upb_def_isfrozen((const upb_def*)self->enumdef)) {
-    rb_raise(rb_eRuntimeError,
-             "Cannot fetch enum module from an EnumDescriptor not yet "
-             "in a pool.");
-  }
   if (self->module == Qnil) {
-    self->module = build_module_from_enumdesc(self);
+    self->module = build_module_from_enumdesc(_self);
   }
   return self->module;
 }
@@ -1479,8 +1411,7 @@ DEFINE_CLASS(MessageBuilderContext,
 
 void MessageBuilderContext_mark(void* _self) {
   MessageBuilderContext* self = _self;
-  rb_gc_mark(self->descriptor);
-  rb_gc_mark(self->builder);
+  rb_gc_mark(self->file_builder);
 }
 
 void MessageBuilderContext_free(void* _self) {
@@ -1492,8 +1423,7 @@ VALUE MessageBuilderContext_alloc(VALUE klass) {
   MessageBuilderContext* self = ALLOC(MessageBuilderContext);
   VALUE ret = TypedData_Wrap_Struct(
       klass, &_MessageBuilderContext_type, self);
-  self->descriptor = Qnil;
-  self->builder = Qnil;
+  self->file_builder = Qnil;
   return ret;
 }
 
@@ -1514,65 +1444,110 @@ void MessageBuilderContext_register(VALUE module) {
 
 /*
  * call-seq:
- *     MessageBuilderContext.new(desc, builder) => context
+ *     MessageBuilderContext.new(file_builder, name) => context
  *
  * Create a new message builder context around the given message descriptor and
  * builder context. This class is intended to serve as a DSL context to be used
  * with #instance_eval.
  */
 VALUE MessageBuilderContext_initialize(VALUE _self,
-                                       VALUE msgdef,
-                                       VALUE builder) {
+                                       VALUE _file_builder,
+                                       VALUE name) {
   DEFINE_SELF(MessageBuilderContext, self, _self);
-  self->descriptor = msgdef;
-  self->builder = builder;
+  FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
+  google_protobuf_FileDescriptorProto* file_proto = file_builder->file_proto;
+
+  self->file_builder = _file_builder;
+  self->msg_proto = google_protobuf_FileDescriptorProto_add_message_type(
+      file_proto, file_builder->arena);
+
+  google_protobuf_DescriptorProto_set_name(
+      self->msg_proto, FileBuilderContext_strdup(_file_builder, name));
+
   return Qnil;
 }
 
-static VALUE msgdef_add_field(VALUE msgdef_rb,
-                              const char* label, VALUE name,
-                              VALUE type, VALUE number,
-                              VALUE type_class,
-                              VALUE options) {
-  VALUE fielddef_rb = rb_class_new_instance(0, NULL, cFieldDescriptor);
-  VALUE name_str = rb_str_new2(rb_id2name(SYM2ID(name)));
+static void msgdef_add_field(VALUE msgbuilder_rb, upb_label_t label, VALUE name,
+                             VALUE type, VALUE number, VALUE type_class,
+                             VALUE options, int oneof_index) {
+  DEFINE_SELF(MessageBuilderContext, self, msgbuilder_rb);
+  FileBuilderContext* file_context =
+      ruby_to_FileBuilderContext(self->file_builder);
+  google_protobuf_FieldDescriptorProto* field_proto;
+  VALUE name_str;
+
+  field_proto = google_protobuf_DescriptorProto_add_field(self->msg_proto,
+                                                          file_context->arena);
+
+  Check_Type(name, T_SYMBOL);
+  name_str = rb_id2str(SYM2ID(name));
 
-  rb_funcall(fielddef_rb, rb_intern("label="), 1, ID2SYM(rb_intern(label)));
-  rb_funcall(fielddef_rb, rb_intern("name="), 1, name_str);
-  rb_funcall(fielddef_rb, rb_intern("type="), 1, type);
-  rb_funcall(fielddef_rb, rb_intern("number="), 1, number);
+  google_protobuf_FieldDescriptorProto_set_name(
+      field_proto, FileBuilderContext_strdup(self->file_builder, name_str));
+  google_protobuf_FieldDescriptorProto_set_number(field_proto, NUM2INT(number));
+  google_protobuf_FieldDescriptorProto_set_label(field_proto, (int)label);
+  google_protobuf_FieldDescriptorProto_set_type(
+      field_proto, (int)ruby_to_descriptortype(type));
 
   if (type_class != Qnil) {
     Check_Type(type_class, T_STRING);
 
     // Make it an absolute type name by prepending a dot.
     type_class = rb_str_append(rb_str_new2("."), type_class);
-    rb_funcall(fielddef_rb, rb_intern("submsg_name="), 1, type_class);
+    google_protobuf_FieldDescriptorProto_set_type_name(
+        field_proto, FileBuilderContext_strdup(self->file_builder, type_class));
   }
 
   if (options != Qnil) {
     Check_Type(options, T_HASH);
 
     if (rb_funcall(options, rb_intern("key?"), 1,
-		   ID2SYM(rb_intern("default"))) == Qtrue) {
-      Descriptor* msgdef = ruby_to_Descriptor(msgdef_rb);
-      if (upb_msgdef_syntax((upb_msgdef*)msgdef->msgdef) == UPB_SYNTAX_PROTO3) {
-        rb_raise(rb_eArgError, "Cannot set :default when using proto3 syntax.");
-      }
+                   ID2SYM(rb_intern("default"))) == Qtrue) {
+      VALUE default_value =
+          rb_hash_lookup(options, ID2SYM(rb_intern("default")));
 
-      FieldDescriptor* fielddef = ruby_to_FieldDescriptor(fielddef_rb);
-      if (!upb_fielddef_haspresence((upb_fielddef*)fielddef->fielddef) ||
-	  upb_fielddef_issubmsg((upb_fielddef*)fielddef->fielddef)) {
-        rb_raise(rb_eArgError, "Cannot set :default on this kind of field.");
-      }
+      /* Call #to_s since all defaults are strings in the descriptor. */
+      default_value = rb_funcall(default_value, rb_intern("to_s"), 0);
 
-      rb_funcall(fielddef_rb, rb_intern("default="), 1,
-		 rb_hash_lookup(options, ID2SYM(rb_intern("default"))));
+      google_protobuf_FieldDescriptorProto_set_default_value(
+          field_proto,
+          FileBuilderContext_strdup(self->file_builder, default_value));
     }
   }
 
-  rb_funcall(msgdef_rb, rb_intern("add_field"), 1, fielddef_rb);
-  return fielddef_rb;
+  if (oneof_index >= 0) {
+    google_protobuf_FieldDescriptorProto_set_oneof_index(field_proto,
+                                                         oneof_index);
+  }
+}
+
+static VALUE make_mapentry(VALUE _message_builder, VALUE types, int argc,
+                           VALUE* argv) {
+  DEFINE_SELF(MessageBuilderContext, message_builder, _message_builder);
+  VALUE type_class = rb_ary_entry(types, 2);
+  FileBuilderContext* file_context =
+      ruby_to_FileBuilderContext(message_builder->file_builder);
+  google_protobuf_MessageOptions* options =
+      google_protobuf_DescriptorProto_mutable_options(
+          message_builder->msg_proto, file_context->arena);
+
+  google_protobuf_MessageOptions_set_map_entry(options, true);
+
+  // optional <type> key = 1;
+  rb_funcall(_message_builder, rb_intern("optional"), 3,
+             ID2SYM(rb_intern("key")), rb_ary_entry(types, 0), INT2NUM(1));
+
+  // optional <type> value = 2;
+  if (type_class == Qnil) {
+    rb_funcall(_message_builder, rb_intern("optional"), 3,
+               ID2SYM(rb_intern("value")), rb_ary_entry(types, 1), INT2NUM(2));
+  } else {
+    rb_funcall(_message_builder, rb_intern("optional"), 4,
+               ID2SYM(rb_intern("value")), rb_ary_entry(types, 1), INT2NUM(2),
+               type_class);
+  }
+
+  return Qnil;
 }
 
 /*
@@ -1586,7 +1561,6 @@ static VALUE msgdef_add_field(VALUE msgdef_rb,
  * string, if present (as accepted by FieldDescriptor#submsg_name=).
  */
 VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
-  DEFINE_SELF(MessageBuilderContext, self, _self);
   VALUE name, type, number;
   VALUE type_class, options = Qnil;
 
@@ -1599,8 +1573,10 @@ VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
     type_class = Qnil;
   }
 
-  return msgdef_add_field(self->descriptor, "optional",
-                          name, type, number, type_class, options);
+  msgdef_add_field(_self, UPB_LABEL_OPTIONAL, name, type, number, type_class,
+                   options, -1);
+
+  return Qnil;
 }
 
 /*
@@ -1618,7 +1594,6 @@ VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
  * pool will currently result in an error.
  */
 VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self) {
-  DEFINE_SELF(MessageBuilderContext, self, _self);
   VALUE name, type, number;
   VALUE type_class, options = Qnil;
 
@@ -1631,8 +1606,10 @@ VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self) {
     type_class = Qnil;
   }
 
-  return msgdef_add_field(self->descriptor, "required",
-                          name, type, number, type_class, options);
+  msgdef_add_field(_self, UPB_LABEL_REQUIRED, name, type, number, type_class,
+                   options, -1);
+
+  return Qnil;
 }
 
 /*
@@ -1645,7 +1622,6 @@ VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self) {
  * string, if present (as accepted by FieldDescriptor#submsg_name=).
  */
 VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self) {
-  DEFINE_SELF(MessageBuilderContext, self, _self);
   VALUE name, type, number, type_class;
 
   if (argc < 3) {
@@ -1656,8 +1632,10 @@ VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self) {
   number = argv[2];
   type_class = (argc > 3) ? argv[3] : Qnil;
 
-  return msgdef_add_field(self->descriptor, "repeated",
-                          name, type, number, type_class, Qnil);
+  msgdef_add_field(_self, UPB_LABEL_REPEATED, name, type, number, type_class,
+                   Qnil, -1);
+
+  return Qnil;
 }
 
 /*
@@ -1675,7 +1653,9 @@ VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self) {
 VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
   DEFINE_SELF(MessageBuilderContext, self, _self);
   VALUE name, key_type, value_type, number, type_class;
-  VALUE mapentry_desc, mapentry_desc_name;
+  VALUE mapentry_desc_name;
+  FileBuilderContext* file_builder;
+  upb_strview msg_name;
 
   if (argc < 4) {
     rb_raise(rb_eArgError, "Expected at least 4 arguments.");
@@ -1698,77 +1678,44 @@ VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
              "type.");
   }
 
-  Descriptor* descriptor = ruby_to_Descriptor(self->descriptor);
-  if (upb_msgdef_syntax(descriptor->msgdef) == UPB_SYNTAX_PROTO2) {
+  file_builder = ruby_to_FileBuilderContext(self->file_builder);
+
+  // TODO(haberman): remove this restriction, maps are supported in proto2.
+  if (upb_strview_eql(
+          google_protobuf_FileDescriptorProto_syntax(file_builder->file_proto),
+          upb_strview_makez("proto2"))) {
     rb_raise(rb_eArgError,
-	     "Cannot add a native map field using proto2 syntax.");
+             "Cannot add a native map field using proto2 syntax.");
   }
 
   // Create a new message descriptor for the map entry message, and create a
   // repeated submessage field here with that type.
-  VALUE file_descriptor_rb =
-      rb_funcall(self->descriptor, rb_intern("file_descriptor"), 0);
-  mapentry_desc = rb_class_new_instance(1, &file_descriptor_rb, cDescriptor);
-  mapentry_desc_name = rb_funcall(self->descriptor, rb_intern("name"), 0);
+  msg_name = google_protobuf_DescriptorProto_name(self->msg_proto);
+  mapentry_desc_name = rb_str_new(msg_name.data, msg_name.size);
   mapentry_desc_name = rb_str_cat2(mapentry_desc_name, "_MapEntry_");
-  mapentry_desc_name = rb_str_cat2(mapentry_desc_name,
-                                   rb_id2name(SYM2ID(name)));
-  Descriptor_name_set(mapentry_desc, mapentry_desc_name);
-
-  {
-    // The 'mapentry' attribute has no Ruby setter because we do not want the
-    // user attempting to DIY the setup below; we want to ensure that the fields
-    // are correct. So we reach into the msgdef here to set the bit manually.
-    Descriptor* mapentry_desc_self = ruby_to_Descriptor(mapentry_desc);
-    upb_msgdef_setmapentry((upb_msgdef*)mapentry_desc_self->msgdef, true);
-  }
-
-  {
-    // optional <type> key = 1;
-    VALUE key_field = rb_class_new_instance(0, NULL, cFieldDescriptor);
-    FieldDescriptor_name_set(key_field, rb_str_new2("key"));
-    FieldDescriptor_label_set(key_field, ID2SYM(rb_intern("optional")));
-    FieldDescriptor_number_set(key_field, INT2NUM(1));
-    FieldDescriptor_type_set(key_field, key_type);
-    Descriptor_add_field(mapentry_desc, key_field);
-  }
+  mapentry_desc_name =
+      rb_str_cat2(mapentry_desc_name, rb_id2name(SYM2ID(name)));
 
   {
-    // optional <type> value = 2;
-    VALUE value_field = rb_class_new_instance(0, NULL, cFieldDescriptor);
-    FieldDescriptor_name_set(value_field, rb_str_new2("value"));
-    FieldDescriptor_label_set(value_field, ID2SYM(rb_intern("optional")));
-    FieldDescriptor_number_set(value_field, INT2NUM(2));
-    FieldDescriptor_type_set(value_field, value_type);
-    if (type_class != Qnil) {
-      VALUE submsg_name = rb_str_new2("."); // prepend '.' to make absolute.
-      submsg_name = rb_str_append(submsg_name, type_class);
-      FieldDescriptor_submsg_name_set(value_field, submsg_name);
-    }
-    Descriptor_add_field(mapentry_desc, value_field);
+    // message <msgname>_MapEntry_ { /* ... */ }
+    VALUE args[1] = {mapentry_desc_name};
+    VALUE types = rb_ary_new3(3, key_type, value_type, type_class);
+    rb_block_call(self->file_builder, rb_intern("add_message"), 1, args,
+                  make_mapentry, types);
   }
 
-  {
-    // Add the map-entry message type to the current builder, and use the type
-    // to create the map field itself.
-    Builder* builder = ruby_to_Builder(self->builder);
-    rb_ary_push(builder->pending_list, mapentry_desc);
+  // If this file is in a package, we need to qualify the map entry type.
+  if (google_protobuf_FileDescriptorProto_has_package(file_builder->file_proto)) {
+    upb_strview package_view =
+        google_protobuf_FileDescriptorProto_package(file_builder->file_proto);
+    VALUE package = rb_str_new(package_view.data, package_view.size);
+    package = rb_str_cat2(package, ".");
+    mapentry_desc_name = rb_str_concat(package, mapentry_desc_name);
   }
 
-  {
-    VALUE map_field = rb_class_new_instance(0, NULL, cFieldDescriptor);
-    VALUE name_str = rb_str_new2(rb_id2name(SYM2ID(name)));
-    VALUE submsg_name;
-
-    FieldDescriptor_name_set(map_field, name_str);
-    FieldDescriptor_number_set(map_field, number);
-    FieldDescriptor_label_set(map_field, ID2SYM(rb_intern("repeated")));
-    FieldDescriptor_type_set(map_field, ID2SYM(rb_intern("message")));
-    submsg_name = rb_str_new2("."); // prepend '.' to make name absolute.
-    submsg_name = rb_str_append(submsg_name, mapentry_desc_name);
-    FieldDescriptor_submsg_name_set(map_field, submsg_name);
-    Descriptor_add_field(self->descriptor, map_field);
-  }
+  // repeated MapEntry <name> = <number>;
+  rb_funcall(_self, rb_intern("repeated"), 4, name,
+             ID2SYM(rb_intern("message")), number, mapentry_desc_name);
 
   return Qnil;
 }
@@ -1786,14 +1733,27 @@ VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
  */
 VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name) {
   DEFINE_SELF(MessageBuilderContext, self, _self);
-  VALUE oneofdef = rb_class_new_instance(0, NULL, cOneofDescriptor);
-  VALUE args[2] = { oneofdef, self->builder };
-  VALUE ctx = rb_class_new_instance(2, args, cOneofBuilderContext);
-  VALUE block = rb_block_proc();
-  VALUE name_str = rb_str_new2(rb_id2name(SYM2ID(name)));
-  rb_funcall(oneofdef, rb_intern("name="), 1, name_str);
-  rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  Descriptor_add_oneof(self->descriptor, oneofdef);
+  size_t oneof_count;
+  FileBuilderContext* file_context =
+      ruby_to_FileBuilderContext(self->file_builder);
+  google_protobuf_OneofDescriptorProto* oneof_proto;
+
+  // Existing oneof_count becomes oneof_index.
+  google_protobuf_DescriptorProto_oneof_decl(self->msg_proto, &oneof_count);
+
+  // Create oneof_proto and set its name.
+  oneof_proto = google_protobuf_DescriptorProto_add_oneof_decl(
+      self->msg_proto, file_context->arena);
+  google_protobuf_OneofDescriptorProto_set_name(
+      oneof_proto, FileBuilderContext_strdup_sym(self->file_builder, name));
+
+  // Evaluate the block with the builder as argument.
+  {
+    VALUE args[2] = { INT2NUM(oneof_count), _self };
+    VALUE ctx = rb_class_new_instance(2, args, cOneofBuilderContext);
+    VALUE block = rb_block_proc();
+    rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
+  }
 
   return Qnil;
 }
@@ -1807,21 +1767,19 @@ DEFINE_CLASS(OneofBuilderContext,
 
 void OneofBuilderContext_mark(void* _self) {
   OneofBuilderContext* self = _self;
-  rb_gc_mark(self->descriptor);
-  rb_gc_mark(self->builder);
+  rb_gc_mark(self->message_builder);
 }
 
 void OneofBuilderContext_free(void* _self) {
-  OneofBuilderContext* self = _self;
-  xfree(self);
+  xfree(_self);
 }
 
 VALUE OneofBuilderContext_alloc(VALUE klass) {
   OneofBuilderContext* self = ALLOC(OneofBuilderContext);
   VALUE ret = TypedData_Wrap_Struct(
       klass, &_OneofBuilderContext_type, self);
-  self->descriptor = Qnil;
-  self->builder = Qnil;
+  self->oneof_index = 0;
+  self->message_builder = Qnil;
   return ret;
 }
 
@@ -1838,18 +1796,18 @@ void OneofBuilderContext_register(VALUE module) {
 
 /*
  * call-seq:
- *     OneofBuilderContext.new(desc, builder) => context
+ *     OneofBuilderContext.new(oneof_index, message_builder) => context
  *
  * Create a new oneof builder context around the given oneof descriptor and
  * builder context. This class is intended to serve as a DSL context to be used
  * with #instance_eval.
  */
 VALUE OneofBuilderContext_initialize(VALUE _self,
-                                     VALUE oneofdef,
-                                     VALUE builder) {
+                                     VALUE oneof_index,
+                                     VALUE message_builder) {
   DEFINE_SELF(OneofBuilderContext, self, _self);
-  self->descriptor = oneofdef;
-  self->builder = builder;
+  self->oneof_index = NUM2INT(oneof_index);
+  self->message_builder = message_builder;
   return Qnil;
 }
 
@@ -1870,8 +1828,10 @@ VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
 
   rb_scan_args(argc, argv, "32", &name, &type, &number, &type_class, &options);
 
-  return msgdef_add_field(self->descriptor, "optional",
-                          name, type, number, type_class, options);
+  msgdef_add_field(self->message_builder, UPB_LABEL_OPTIONAL, name, type,
+                   number, type_class, options, self->oneof_index);
+
+  return Qnil;
 }
 
 // -----------------------------------------------------------------------------
@@ -1883,19 +1843,19 @@ DEFINE_CLASS(EnumBuilderContext,
 
 void EnumBuilderContext_mark(void* _self) {
   EnumBuilderContext* self = _self;
-  rb_gc_mark(self->enumdesc);
+  rb_gc_mark(self->file_builder);
 }
 
 void EnumBuilderContext_free(void* _self) {
-  EnumBuilderContext* self = _self;
-  xfree(self);
+  xfree(_self);
 }
 
 VALUE EnumBuilderContext_alloc(VALUE klass) {
   EnumBuilderContext* self = ALLOC(EnumBuilderContext);
   VALUE ret = TypedData_Wrap_Struct(
       klass, &_EnumBuilderContext_type, self);
-  self->enumdesc = Qnil;
+  self->enum_proto = NULL;
+  self->file_builder = Qnil;
   return ret;
 }
 
@@ -1903,8 +1863,7 @@ void EnumBuilderContext_register(VALUE module) {
   VALUE klass = rb_define_class_under(
       module, "EnumBuilderContext", rb_cObject);
   rb_define_alloc_func(klass, EnumBuilderContext_alloc);
-  rb_define_method(klass, "initialize",
-                   EnumBuilderContext_initialize, 1);
+  rb_define_method(klass, "initialize", EnumBuilderContext_initialize, 2);
   rb_define_method(klass, "value", EnumBuilderContext_value, 2);
   rb_gc_register_address(&cEnumBuilderContext);
   cEnumBuilderContext = klass;
@@ -1912,20 +1871,24 @@ void EnumBuilderContext_register(VALUE module) {
 
 /*
  * call-seq:
- *     EnumBuilderContext.new(enumdesc) => context
+ *     EnumBuilderContext.new(file_builder) => context
  *
  * Create a new builder context around the given enum descriptor. This class is
  * intended to serve as a DSL context to be used with #instance_eval.
  */
-VALUE EnumBuilderContext_initialize(VALUE _self, VALUE enumdef) {
+VALUE EnumBuilderContext_initialize(VALUE _self, VALUE _file_builder,
+                                    VALUE name) {
   DEFINE_SELF(EnumBuilderContext, self, _self);
-  self->enumdesc = enumdef;
-  return Qnil;
-}
+  FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
+  google_protobuf_FileDescriptorProto* file_proto = file_builder->file_proto;
+
+  self->file_builder = _file_builder;
+  self->enum_proto = google_protobuf_FileDescriptorProto_add_enum_type(
+      file_proto, file_builder->arena);
+
+  google_protobuf_EnumDescriptorProto_set_name(
+      self->enum_proto, FileBuilderContext_strdup(_file_builder, name));
 
-static VALUE enumdef_add_value(VALUE enumdef,
-                               VALUE name, VALUE number) {
-  rb_funcall(enumdef, rb_intern("add_value"), 2, name, number);
   return Qnil;
 }
 
@@ -1938,7 +1901,19 @@ static VALUE enumdef_add_value(VALUE enumdef,
  */
 VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number) {
   DEFINE_SELF(EnumBuilderContext, self, _self);
-  return enumdef_add_value(self->enumdesc, name, number);
+  FileBuilderContext* file_builder =
+      ruby_to_FileBuilderContext(self->file_builder);
+  google_protobuf_EnumValueDescriptorProto* enum_value;
+
+  enum_value = google_protobuf_EnumDescriptorProto_add_value(
+      self->enum_proto, file_builder->arena);
+
+  google_protobuf_EnumValueDescriptorProto_set_name(
+      enum_value, FileBuilderContext_strdup_sym(self->file_builder, name));
+  google_protobuf_EnumValueDescriptorProto_set_number(enum_value,
+                                                      NUM2INT(number));
+
+  return Qnil;
 }
 
 
@@ -1947,33 +1922,55 @@ VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number) {
 // -----------------------------------------------------------------------------
 
 DEFINE_CLASS(FileBuilderContext,
-	     "Google::Protobuf::Internal::FileBuilderContext");
+             "Google::Protobuf::Internal::FileBuilderContext");
 
 void FileBuilderContext_mark(void* _self) {
   FileBuilderContext* self = _self;
-  rb_gc_mark(self->pending_list);
-  rb_gc_mark(self->file_descriptor);
-  rb_gc_mark(self->builder);
+  rb_gc_mark(self->descriptor_pool);
 }
 
 void FileBuilderContext_free(void* _self) {
   FileBuilderContext* self = _self;
+  upb_arena_free(self->arena);
   xfree(self);
 }
 
+upb_strview FileBuilderContext_strdup2(VALUE _self, const char *str) {
+  DEFINE_SELF(FileBuilderContext, self, _self);
+  upb_strview ret;
+  char *data;
+
+  ret.size = strlen(str);
+  data = upb_malloc(upb_arena_alloc(self->arena), ret.size + 1);
+  ret.data = data;
+  memcpy(data, str, ret.size);
+  /* Null-terminate required by rewrite_enum_defaults() above. */
+  data[ret.size] = '\0';
+  return ret;
+}
+
+upb_strview FileBuilderContext_strdup(VALUE _self, VALUE rb_str) {
+  return FileBuilderContext_strdup2(_self, get_str(rb_str));
+}
+
+upb_strview FileBuilderContext_strdup_sym(VALUE _self, VALUE rb_sym) {
+  Check_Type(rb_sym, T_SYMBOL);
+  return FileBuilderContext_strdup(_self, rb_id2str(SYM2ID(rb_sym)));
+}
+
 VALUE FileBuilderContext_alloc(VALUE klass) {
   FileBuilderContext* self = ALLOC(FileBuilderContext);
   VALUE ret = TypedData_Wrap_Struct(klass, &_FileBuilderContext_type, self);
-  self->pending_list = Qnil;
-  self->file_descriptor = Qnil;
-  self->builder = Qnil;
+  self->arena = upb_arena_new();
+  self->file_proto = google_protobuf_FileDescriptorProto_new(self->arena);
+  self->descriptor_pool = Qnil;
   return ret;
 }
 
 void FileBuilderContext_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "FileBuilderContext", rb_cObject);
   rb_define_alloc_func(klass, FileBuilderContext_alloc);
-  rb_define_method(klass, "initialize", FileBuilderContext_initialize, 2);
+  rb_define_method(klass, "initialize", FileBuilderContext_initialize, 3);
   rb_define_method(klass, "add_message", FileBuilderContext_add_message, 1);
   rb_define_method(klass, "add_enum", FileBuilderContext_add_enum, 1);
   rb_gc_register_address(&cFileBuilderContext);
@@ -1982,18 +1979,41 @@ void FileBuilderContext_register(VALUE module) {
 
 /*
  * call-seq:
- *     FileBuilderContext.new(file_descriptor, builder) => context
+ *     FileBuilderContext.new(descriptor_pool) => context
  *
  * Create a new file builder context for the given file descriptor and
  * builder context. This class is intended to serve as a DSL context to be used
  * with #instance_eval.
  */
-VALUE FileBuilderContext_initialize(VALUE _self, VALUE file_descriptor,
-				    VALUE builder) {
+VALUE FileBuilderContext_initialize(VALUE _self, VALUE descriptor_pool,
+                                    VALUE name, VALUE options) {
   DEFINE_SELF(FileBuilderContext, self, _self);
-  self->pending_list = rb_ary_new();
-  self->file_descriptor = file_descriptor;
-  self->builder = builder;
+  self->descriptor_pool = descriptor_pool;
+
+  google_protobuf_FileDescriptorProto_set_name(
+      self->file_proto, FileBuilderContext_strdup(_self, name));
+
+  // Default syntax for Ruby is proto3.
+  google_protobuf_FileDescriptorProto_set_syntax(
+      self->file_proto,
+      FileBuilderContext_strdup(_self, rb_str_new2("proto3")));
+
+  if (options != Qnil) {
+    VALUE syntax;
+
+    Check_Type(options, T_HASH);
+    syntax = rb_hash_lookup2(options, ID2SYM(rb_intern("syntax")), Qnil);
+
+    if (syntax != Qnil) {
+      VALUE syntax_str;
+
+      Check_Type(syntax, T_SYMBOL);
+      syntax_str = rb_id2str(SYM2ID(syntax));
+      google_protobuf_FileDescriptorProto_set_syntax(
+          self->file_proto, FileBuilderContext_strdup(_self, syntax_str));
+    }
+  }
+
   return Qnil;
 }
 
@@ -2009,14 +2029,10 @@ VALUE FileBuilderContext_initialize(VALUE _self, VALUE file_descriptor,
  * This is the recommended, idiomatic way to build message definitions.
  */
 VALUE FileBuilderContext_add_message(VALUE _self, VALUE name) {
-  DEFINE_SELF(FileBuilderContext, self, _self);
-  VALUE msgdef = rb_class_new_instance(1, &self->file_descriptor, cDescriptor);
-  VALUE args[2] = { msgdef, self->builder };
+  VALUE args[2] = { _self, name };
   VALUE ctx = rb_class_new_instance(2, args, cMessageBuilderContext);
   VALUE block = rb_block_proc();
-  rb_funcall(msgdef, rb_intern("name="), 1, name);
   rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  rb_ary_push(self->pending_list, msgdef);
   return Qnil;
 }
 
@@ -2031,20 +2047,26 @@ VALUE FileBuilderContext_add_message(VALUE _self, VALUE name) {
  * This is the recommended, idiomatic way to build enum definitions.
  */
 VALUE FileBuilderContext_add_enum(VALUE _self, VALUE name) {
-  DEFINE_SELF(FileBuilderContext, self, _self);
-  VALUE enumdef =
-      rb_class_new_instance(1, &self->file_descriptor, cEnumDescriptor);
-  VALUE ctx = rb_class_new_instance(1, &enumdef, cEnumBuilderContext);
+  VALUE args[2] = { _self, name };
+  VALUE ctx = rb_class_new_instance(2, args, cEnumBuilderContext);
   VALUE block = rb_block_proc();
-  rb_funcall(enumdef, rb_intern("name="), 1, name);
   rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  rb_ary_push(self->pending_list, enumdef);
   return Qnil;
 }
 
-VALUE FileBuilderContext_pending_descriptors(VALUE _self) {
+void FileBuilderContext_build(VALUE _self) {
   DEFINE_SELF(FileBuilderContext, self, _self);
-  return self->pending_list;
+  DescriptorPool* pool = ruby_to_DescriptorPool(self->descriptor_pool);
+  upb_status status;
+
+  rewrite_enum_defaults(pool->symtab, self->file_proto);
+  rewrite_names(_self, self->file_proto);
+
+  upb_status_clear(&status);
+  if (!upb_symtab_addfile(pool->symtab, self->file_proto, &status)) {
+    rb_raise(cTypeError, "Unable to add defs to DescriptorPool: %s",
+             upb_status_errmsg(&status));
+  }
 }
 
 // -----------------------------------------------------------------------------
@@ -2055,58 +2077,46 @@ DEFINE_CLASS(Builder, "Google::Protobuf::Internal::Builder");
 
 void Builder_mark(void* _self) {
   Builder* self = _self;
-  rb_gc_mark(self->pending_list);
-  rb_gc_mark(self->default_file_descriptor);
+  rb_gc_mark(self->descriptor_pool);
+  rb_gc_mark(self->default_file_builder);
 }
 
 void Builder_free(void* _self) {
-  Builder* self = _self;
-  xfree(self->defs);
-  xfree(self);
+  xfree(_self);
 }
 
-/*
- * call-seq:
- *     Builder.new => builder
- *
- * Creates a new Builder. A Builder can accumulate a set of new message and enum
- * descriptors and atomically register them into a pool in a way that allows for
- * (co)recursive type references.
- */
 VALUE Builder_alloc(VALUE klass) {
   Builder* self = ALLOC(Builder);
   VALUE ret = TypedData_Wrap_Struct(
       klass, &_Builder_type, self);
-  self->pending_list = Qnil;
-  self->defs = NULL;
-  self->default_file_descriptor = Qnil;
+  self->descriptor_pool = Qnil;
+  self->default_file_builder = Qnil;
   return ret;
 }
 
 void Builder_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "Builder", rb_cObject);
-  rb_define_alloc_func(klass, Builder_alloc);
-  rb_define_method(klass, "initialize", Builder_initialize, 0);
+  rb_define_alloc_func(klass, Builder_alloc); 
+  rb_define_method(klass, "initialize", Builder_initialize, 1);
   rb_define_method(klass, "add_file", Builder_add_file, -1);
   rb_define_method(klass, "add_message", Builder_add_message, 1);
   rb_define_method(klass, "add_enum", Builder_add_enum, 1);
-  rb_define_method(klass, "finalize_to_pool", Builder_finalize_to_pool, 1);
   rb_gc_register_address(&cBuilder);
   cBuilder = klass;
 }
 
 /*
  * call-seq:
- *    Builder.new
+ *     Builder.new(descriptor_pool) => builder
  *
- * Initializes a new builder.
+ * Creates a new Builder. A Builder can accumulate a set of new message and enum
+ * descriptors and atomically register them into a pool in a way that allows for
+ * (co)recursive type references.
  */
-VALUE Builder_initialize(VALUE _self) {
+VALUE Builder_initialize(VALUE _self, VALUE pool) {
   DEFINE_SELF(Builder, self, _self);
-  self->pending_list = rb_ary_new();
-  VALUE file_name = Qnil;
-  self->default_file_descriptor =
-      rb_class_new_instance(1, &file_name, cFileDescriptor);
+  self->descriptor_pool = pool;
+  self->default_file_builder = Qnil;  // Created lazily if needed.
   return Qnil;
 }
 
@@ -2123,17 +2133,38 @@ VALUE Builder_initialize(VALUE _self) {
  */
 VALUE Builder_add_file(int argc, VALUE* argv, VALUE _self) {
   DEFINE_SELF(Builder, self, _self);
-  VALUE file_descriptor = rb_class_new_instance(argc, argv, cFileDescriptor);
-  VALUE args[2] = { file_descriptor, _self };
-  VALUE ctx = rb_class_new_instance(2, args, cFileBuilderContext);
-  VALUE block = rb_block_proc();
+  VALUE name, options;
+  VALUE ctx;
+  VALUE block;
+
+  rb_scan_args(argc, argv, "11", &name, &options);
+
+  {
+    VALUE args[3] = { self->descriptor_pool, name, options };
+    ctx = rb_class_new_instance(3, args, cFileBuilderContext);
+  }
+
+  block = rb_block_proc();
   rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
+  FileBuilderContext_build(ctx);
 
-  rb_ary_concat(self->pending_list,
-      FileBuilderContext_pending_descriptors(ctx));
   return Qnil;
 }
 
+static VALUE Builder_get_default_file(VALUE _self) {
+  DEFINE_SELF(Builder, self, _self);
+
+  /* Lazily create only if legacy builder-level methods are called. */
+  if (self->default_file_builder == Qnil) {
+    VALUE name = rb_str_new2("ruby_default_file.proto");
+    VALUE args [3] = { self->descriptor_pool, name, rb_hash_new() };
+    self->default_file_builder =
+        rb_class_new_instance(3, args, cFileBuilderContext);
+  }
+
+  return self->default_file_builder;
+}
+
 /*
  * call-seq:
  *     Builder.add_message(name, &block)
@@ -2146,15 +2177,9 @@ VALUE Builder_add_file(int argc, VALUE* argv, VALUE _self) {
  * Descriptors created this way get assigned to a default empty FileDescriptor.
  */
 VALUE Builder_add_message(VALUE _self, VALUE name) {
-  DEFINE_SELF(Builder, self, _self);
-  VALUE msgdef =
-      rb_class_new_instance(1, &self->default_file_descriptor, cDescriptor);
-  VALUE args[2] = { msgdef, _self };
-  VALUE ctx = rb_class_new_instance(2, args, cMessageBuilderContext);
-  VALUE block = rb_block_proc();
-  rb_funcall(msgdef, rb_intern("name="), 1, name);
-  rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  rb_ary_push(self->pending_list, msgdef);
+  VALUE file_builder = Builder_get_default_file(_self);
+  rb_funcall_with_block(file_builder, rb_intern("add_message"), 1, &name,
+                        rb_block_proc());
   return Qnil;
 }
 
@@ -2171,87 +2196,83 @@ VALUE Builder_add_message(VALUE _self, VALUE name) {
  * FileDescriptor.
  */
 VALUE Builder_add_enum(VALUE _self, VALUE name) {
-  DEFINE_SELF(Builder, self, _self);
-  VALUE enumdef =
-      rb_class_new_instance(1, &self->default_file_descriptor, cEnumDescriptor);
-  VALUE ctx = rb_class_new_instance(1, &enumdef, cEnumBuilderContext);
-  VALUE block = rb_block_proc();
-  rb_funcall(enumdef, rb_intern("name="), 1, name);
-  rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  rb_ary_push(self->pending_list, enumdef);
+  VALUE file_builder = Builder_get_default_file(_self);
+  rb_funcall_with_block(file_builder, rb_intern("add_enum"), 1, &name,
+                        rb_block_proc());
   return Qnil;
 }
 
-static void proto3_validate_msgdef(const upb_msgdef* msgdef) {
-  // Verify that no required fields exist. proto3 does not support these.
-  upb_msg_field_iter it;
-  for (upb_msg_field_begin(&it, msgdef);
-       !upb_msg_field_done(&it);
-       upb_msg_field_next(&it)) {
-    const upb_fielddef* field = upb_msg_iter_field(&it);
-    if (upb_fielddef_label(field) == UPB_LABEL_REQUIRED) {
-      rb_raise(cTypeError, "Required fields are unsupported in proto3.");
-    }
-  }
-}
+/* This method is hidden from Ruby, and only called directly from
+ * DescriptorPool_build(). */
+VALUE Builder_build(VALUE _self) {
+  DEFINE_SELF(Builder, self, _self);
 
-static void proto3_validate_enumdef(const upb_enumdef* enumdef) {
-  // Verify that an entry exists with integer value 0. (This is the default
-  // value.)
-  const char* lookup = upb_enumdef_iton(enumdef, 0);
-  if (lookup == NULL) {
-    rb_raise(cTypeError,
-             "Enum definition does not contain a value for '0'.");
+  if (self->default_file_builder != Qnil) {
+    FileBuilderContext_build(self->default_file_builder);
+    self->default_file_builder = Qnil;
   }
-}
-
-/*
- * call-seq:
- *     Builder.finalize_to_pool(pool)
- *
- * Adds all accumulated message and enum descriptors created in this builder
- * context to the given pool. The operation occurs atomically, and all
- * descriptors can refer to each other (including in cycles). This is the only
- * way to build (co)recursive message definitions.
- *
- * This method is usually called automatically by DescriptorPool#build after it
- * invokes the given user block in the context of the builder. The user should
- * not normally need to call this manually because a Builder is not normally
- * created manually.
- */
-VALUE Builder_finalize_to_pool(VALUE _self, VALUE pool_rb) {
-  DEFINE_SELF(Builder, self, _self);
 
-  DescriptorPool* pool = ruby_to_DescriptorPool(pool_rb);
+  return Qnil;
+}
 
-  REALLOC_N(self->defs, upb_def*, RARRAY_LEN(self->pending_list));
+static VALUE get_def_obj(VALUE _descriptor_pool, const void* ptr, VALUE klass) {
+  DEFINE_SELF(DescriptorPool, descriptor_pool, _descriptor_pool);
+  VALUE key = ULL2NUM((intptr_t)ptr);
+  VALUE def;
 
-  for (int i = 0; i < RARRAY_LEN(self->pending_list); i++) {
-    VALUE def_rb = rb_ary_entry(self->pending_list, i);
-    if (CLASS_OF(def_rb) == cDescriptor) {
-      self->defs[i] = (upb_def*)ruby_to_Descriptor(def_rb)->msgdef;
+  def = rb_hash_aref(descriptor_pool->def_to_descriptor, key);
 
-      if (upb_filedef_syntax(upb_def_file(self->defs[i])) == UPB_SYNTAX_PROTO3) {
-        proto3_validate_msgdef((const upb_msgdef*)self->defs[i]);
-      }
-    } else if (CLASS_OF(def_rb) == cEnumDescriptor) {
-      self->defs[i] = (upb_def*)ruby_to_EnumDescriptor(def_rb)->enumdef;
+  if (ptr == NULL) {
+    return Qnil;
+  }
 
-      if (upb_filedef_syntax(upb_def_file(self->defs[i])) == UPB_SYNTAX_PROTO3) {
-        proto3_validate_enumdef((const upb_enumdef*)self->defs[i]);
+  if (def == Qnil) {
+    // Lazily create wrapper object.
+    VALUE args[3] = { c_only_cookie, _descriptor_pool, key };
+    def = rb_class_new_instance(3, args, klass);
+    rb_hash_aset(descriptor_pool->def_to_descriptor, key, def);
+
+    // For message defs, we now eagerly get/create descriptors for all
+    // submessages.  We will need these anyway to parse or serialize this
+    // message type.  But more importantly, we must do this now so that
+    // add_handlers_for_message() (which calls get_msgdef_obj()) does *not*
+    // need to create a Ruby object or insert into a Ruby Hash.  We need to
+    // avoid triggering GC, which can switch Ruby threads and re-enter our
+    // C extension from a different thread.  This wreaks havoc on our state
+    // if we were in the middle of building handlers.
+    if (klass == cDescriptor) {
+      const upb_msgdef *m = ptr;
+      upb_msg_field_iter it;
+      for (upb_msg_field_begin(&it, m);
+           !upb_msg_field_done(&it);
+           upb_msg_field_next(&it)) {
+        const upb_fielddef* f = upb_msg_iter_field(&it);
+        if (upb_fielddef_issubmsg(f)) {
+          get_msgdef_obj(_descriptor_pool, upb_fielddef_msgsubdef(f));
+        }
       }
     }
   }
 
-  CHECK_UPB(upb_symtab_add(pool->symtab, (upb_def**)self->defs,
-                           RARRAY_LEN(self->pending_list), NULL, &status),
-            "Unable to add defs to DescriptorPool");
+  return def;
+}
 
-  for (int i = 0; i < RARRAY_LEN(self->pending_list); i++) {
-    VALUE def_rb = rb_ary_entry(self->pending_list, i);
-    add_def_obj(self->defs[i], def_rb);
-  }
+VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_msgdef* def) {
+  return get_def_obj(descriptor_pool, def, cDescriptor);
+}
 
-  self->pending_list = rb_ary_new();
-  return Qnil;
+VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_enumdef* def) {
+  return get_def_obj(descriptor_pool, def, cEnumDescriptor);
+}
+
+VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_fielddef* def) {
+  return get_def_obj(descriptor_pool, def, cFieldDescriptor);
+}
+
+VALUE get_filedef_obj(VALUE descriptor_pool, const upb_filedef* def) {
+  return get_def_obj(descriptor_pool, def, cFileDescriptor);
+}
+
+VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_oneofdef* def) {
+  return get_def_obj(descriptor_pool, def, cOneofDescriptor);
 }