google-protobuf 3.14.0-universal-darwin → 3.15.0.rc.1-universal-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c8a5ef5f8b2ec2299d076a864f7e3ccf8d888869a109ffec9a82cf07620c56b
-  data.tar.gz: e4c919b399af4d717118c645e975c2db00e6c8e51bc7d38b7017985b7d5a1584
+  metadata.gz: 43956c925fb5f7275c416f7637e4281c7a066de1a5bb997c96383bfa5953c981
+  data.tar.gz: f1ed1ea4e8b3def827613be7630b0fec65c718843c216b2ead2ea889fb9f2fcc
 SHA512:
-  metadata.gz: 3393e76bcc08d29b6321d660efd2f5fa48a4a2ac0d59bb5c24a9708f17891129fb313220da81df58d07d0f4a174d2cc70a3c49d3233c9adac60b4f3576aa874c
-  data.tar.gz: 6ca9760320cb431def9f0b23457a8779a7a7de1a3d0898cb1b0f0deadc8dcc440be73679e038057686eba046abff1fd4d07c9b17a4459a332f2488a89bd8909a
+  metadata.gz: '028637bb834fe5b78a77340c6964b734bb9ff94660501a8d9bf477da79ce4e8d0f93f7bdc37a1d6b2f3b7fe09213f881084cc9a84d00a60de4985af1a8baa7ba'
+  data.tar.gz: e76dfaa3cf0d49316392678dd59595336e3e1156281e8b64425e5b7168cbb00792341f8dbea7653a17ffa7592113383d62783e88b701b48c69cdfc578ef0cfa6

data/ext/google/protobuf_c/convert.c

@@ -0,0 +1,349 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// -----------------------------------------------------------------------------
+// Ruby <-> upb data conversion functions.
+//
+// This file Also contains a few other assorted algorithms on upb_msgval.
+//
+// None of the algorithms in this file require any access to the internal
+// representation of Ruby or upb objects.
+// -----------------------------------------------------------------------------
+
+#include "convert.h"
+
+#include "message.h"
+#include "protobuf.h"
+#include "third_party/wyhash/wyhash.h"
+
+static upb_strview Convert_StringData(VALUE str, upb_arena *arena) {
+  upb_strview ret;
+  if (arena) {
+    char *ptr = upb_arena_malloc(arena, RSTRING_LEN(str));
+    memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
+    ret.data = ptr;
+  } else {
+    // Data is only needed temporarily (within map lookup).
+    ret.data = RSTRING_PTR(str);
+  }
+  ret.size = RSTRING_LEN(str);
+  return ret;
+}
+
+static bool is_ruby_num(VALUE value) {
+  return (TYPE(value) == T_FLOAT ||
+          TYPE(value) == T_FIXNUM ||
+          TYPE(value) == T_BIGNUM);
+}
+
+static void Convert_CheckInt(const char* name, upb_fieldtype_t type,
+                             VALUE val) {
+  if (!is_ruby_num(val)) {
+    rb_raise(cTypeError,
+             "Expected number type for integral field '%s' (given %s).", name,
+             rb_class2name(CLASS_OF(val)));
+  }
+
+  // NUM2{INT,UINT,LL,ULL} macros do the appropriate range checks on upper
+  // bound; we just need to do precision checks (i.e., disallow rounding) and
+  // check for < 0 on unsigned types.
+  if (TYPE(val) == T_FLOAT) {
+    double dbl_val = NUM2DBL(val);
+    if (floor(dbl_val) != dbl_val) {
+      rb_raise(rb_eRangeError,
+               "Non-integral floating point value assigned to integer field "
+               "'%s' (given %s).",
+               name, rb_class2name(CLASS_OF(val)));
+    }
+  }
+  if (type == UPB_TYPE_UINT32 || type == UPB_TYPE_UINT64) {
+    if (NUM2DBL(val) < 0) {
+      rb_raise(
+          rb_eRangeError,
+          "Assigning negative value to unsigned integer field '%s' (given %s).",
+          name, rb_class2name(CLASS_OF(val)));
+    }
+  }
+}
+
+static int32_t Convert_ToEnum(VALUE value, const char* name,
+                              const upb_enumdef* e) {
+  int32_t val;
+
+  switch (TYPE(value)) {
+    case T_FLOAT:
+    case T_FIXNUM:
+    case T_BIGNUM:
+      Convert_CheckInt(name, UPB_TYPE_INT32, value);
+      val = NUM2INT(value);
+      break;
+    case T_STRING:
+      if (!upb_enumdef_ntoi(e, RSTRING_PTR(value), RSTRING_LEN(value), &val)) {
+        goto unknownval;
+      }
+      break;
+    case T_SYMBOL:
+      if (!upb_enumdef_ntoiz(e, rb_id2name(SYM2ID(value)), &val)) {
+        goto unknownval;
+      }
+      break;
+    default:
+      rb_raise(cTypeError,
+               "Expected number or symbol type for enum field '%s'.", name);
+  }
+
+  return val;
+
+unknownval:
+  rb_raise(rb_eRangeError, "Unknown symbol value for enum field '%s'.", name);
+}
+
+upb_msgval Convert_RubyToUpb(VALUE value, const char* name, TypeInfo type_info,
+                             upb_arena* arena) {
+  upb_msgval ret;
+
+  switch (type_info.type) {
+    case UPB_TYPE_FLOAT:
+      if (!is_ruby_num(value)) {
+        rb_raise(cTypeError, "Expected number type for float field '%s' (given %s).",
+                 name, rb_class2name(CLASS_OF(value)));
+      }
+      ret.float_val = NUM2DBL(value);
+      break;
+    case UPB_TYPE_DOUBLE:
+      if (!is_ruby_num(value)) {
+        rb_raise(cTypeError, "Expected number type for double field '%s' (given %s).",
+                 name, rb_class2name(CLASS_OF(value)));
+      }
+      ret.double_val = NUM2DBL(value);
+      break;
+    case UPB_TYPE_BOOL: {
+      if (value == Qtrue) {
+        ret.bool_val = 1;
+      } else if (value == Qfalse) {
+        ret.bool_val = 0;
+      } else {
+        rb_raise(cTypeError, "Invalid argument for boolean field '%s' (given %s).",
+                 name, rb_class2name(CLASS_OF(value)));
+      }
+      break;
+    }
+    case UPB_TYPE_STRING: {
+      VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
+      if (CLASS_OF(value) == rb_cSymbol) {
+        value = rb_funcall(value, rb_intern("to_s"), 0);
+      } else if (CLASS_OF(value) != rb_cString) {
+        rb_raise(cTypeError, "Invalid argument for string field '%s' (given %s).",
+                 name, rb_class2name(CLASS_OF(value)));
+      }
+
+      if (rb_obj_encoding(value) != utf8) {
+        // Note: this will not duplicate underlying string data unless necessary.
+        value = rb_str_encode(value, utf8, 0, Qnil);
+
+        if (rb_enc_str_coderange(value) == ENC_CODERANGE_BROKEN) {
+          rb_raise(rb_eEncodingError, "String is invalid UTF-8");
+        }
+      }
+
+      ret.str_val = Convert_StringData(value, arena);
+      break;
+    }
+    case UPB_TYPE_BYTES: {
+      VALUE bytes = rb_enc_from_encoding(rb_ascii8bit_encoding());
+      if (CLASS_OF(value) != rb_cString) {
+        rb_raise(cTypeError, "Invalid argument for bytes field '%s' (given %s).",
+                 name, rb_class2name(CLASS_OF(value)));
+      }
+
+      if (rb_obj_encoding(value) != bytes) {
+        // Note: this will not duplicate underlying string data unless necessary.
+        // TODO(haberman): is this really necessary to get raw bytes?
+        value = rb_str_encode(value, bytes, 0, Qnil);
+      }
+
+      ret.str_val = Convert_StringData(value, arena);
+      break;
+    }
+    case UPB_TYPE_MESSAGE:
+      ret.msg_val =
+          Message_GetUpbMessage(value, type_info.def.msgdef, name, arena);
+      break;
+    case UPB_TYPE_ENUM:
+      ret.int32_val = Convert_ToEnum(value, name, type_info.def.enumdef);
+      break;
+    case UPB_TYPE_INT32:
+    case UPB_TYPE_INT64:
+    case UPB_TYPE_UINT32:
+    case UPB_TYPE_UINT64:
+      Convert_CheckInt(name, type_info.type, value);
+      switch (type_info.type) {
+      case UPB_TYPE_INT32:
+        ret.int32_val = NUM2INT(value);
+        break;
+      case UPB_TYPE_INT64:
+        ret.int64_val = NUM2LL(value);
+        break;
+      case UPB_TYPE_UINT32:
+        ret.uint32_val = NUM2UINT(value);
+        break;
+      case UPB_TYPE_UINT64:
+        ret.uint64_val = NUM2ULL(value);
+        break;
+      default:
+        break;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena) {
+  switch (type_info.type) {
+    case UPB_TYPE_FLOAT:
+      return DBL2NUM(upb_val.float_val);
+    case UPB_TYPE_DOUBLE:
+      return DBL2NUM(upb_val.double_val);
+    case UPB_TYPE_BOOL:
+      return upb_val.bool_val ? Qtrue : Qfalse;
+    case UPB_TYPE_INT32:
+      return INT2NUM(upb_val.int32_val);
+    case UPB_TYPE_INT64:
+      return LL2NUM(upb_val.int64_val);
+    case UPB_TYPE_UINT32:
+      return UINT2NUM(upb_val.uint32_val);
+    case UPB_TYPE_UINT64:
+      return ULL2NUM(upb_val.int64_val);
+    case UPB_TYPE_ENUM: {
+      const char* name =
+          upb_enumdef_iton(type_info.def.enumdef, upb_val.int32_val);
+      if (name) {
+        return ID2SYM(rb_intern(name));
+      } else {
+        return INT2NUM(upb_val.int32_val);
+      }
+    }
+    case UPB_TYPE_STRING: {
+      VALUE str_rb = rb_str_new(upb_val.str_val.data, upb_val.str_val.size);
+      rb_enc_associate(str_rb, rb_utf8_encoding());
+      rb_obj_freeze(str_rb);
+      return str_rb;
+    }
+    case UPB_TYPE_BYTES: {
+      VALUE str_rb = rb_str_new(upb_val.str_val.data, upb_val.str_val.size);
+      rb_enc_associate(str_rb, rb_ascii8bit_encoding());
+      rb_obj_freeze(str_rb);
+      return str_rb;
+    }
+    case UPB_TYPE_MESSAGE:
+      return Message_GetRubyWrapper((upb_msg*)upb_val.msg_val,
+                                    type_info.def.msgdef, arena);
+    default:
+      rb_raise(rb_eRuntimeError, "Convert_UpbToRuby(): Unexpected type %d",
+               (int)type_info.type);
+  }
+}
+
+upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
+                           upb_arena* arena) {
+  upb_msgval new_msgval;
+
+  switch (type_info.type) {
+    default:
+      memcpy(&new_msgval, &msgval, sizeof(msgval));
+      break;
+    case UPB_TYPE_STRING:
+    case UPB_TYPE_BYTES: {
+      size_t n = msgval.str_val.size;
+      char *mem = upb_arena_malloc(arena, n);
+      new_msgval.str_val.data = mem;
+      new_msgval.str_val.size = n;
+      memcpy(mem, msgval.str_val.data, n);
+      break;
+    }
+    case UPB_TYPE_MESSAGE:
+      new_msgval.msg_val =
+          Message_deep_copy(msgval.msg_val, type_info.def.msgdef, arena);
+      break;
+  }
+
+  return new_msgval;
+}
+
+bool Msgval_IsEqual(upb_msgval val1, upb_msgval val2, TypeInfo type_info) {
+  switch (type_info.type) {
+    case UPB_TYPE_BOOL:
+      return memcmp(&val1, &val2, 1) == 0;
+    case UPB_TYPE_FLOAT:
+    case UPB_TYPE_INT32:
+    case UPB_TYPE_UINT32:
+    case UPB_TYPE_ENUM:
+      return memcmp(&val1, &val2, 4) == 0;
+    case UPB_TYPE_DOUBLE:
+    case UPB_TYPE_INT64:
+    case UPB_TYPE_UINT64:
+      return memcmp(&val1, &val2, 8) == 0;
+    case UPB_TYPE_STRING:
+    case UPB_TYPE_BYTES:
+      return val1.str_val.size != val2.str_val.size ||
+             memcmp(val1.str_val.data, val2.str_val.data,
+                    val1.str_val.size) == 0;
+    case UPB_TYPE_MESSAGE:
+      return Message_Equal(val1.msg_val, val2.msg_val, type_info.def.msgdef);
+    default:
+      rb_raise(rb_eRuntimeError, "Internal error, unexpected type");
+  }
+}
+
+uint64_t Msgval_GetHash(upb_msgval val, TypeInfo type_info, uint64_t seed) {
+  switch (type_info.type) {
+    case UPB_TYPE_BOOL:
+      return wyhash(&val, 1, seed, _wyp);
+    case UPB_TYPE_FLOAT:
+    case UPB_TYPE_INT32:
+    case UPB_TYPE_UINT32:
+    case UPB_TYPE_ENUM:
+      return wyhash(&val, 4, seed, _wyp);
+    case UPB_TYPE_DOUBLE:
+    case UPB_TYPE_INT64:
+    case UPB_TYPE_UINT64:
+      return wyhash(&val, 8, seed, _wyp);
+    case UPB_TYPE_STRING:
+    case UPB_TYPE_BYTES:
+      return wyhash(val.str_val.data, val.str_val.size, seed, _wyp);
+    case UPB_TYPE_MESSAGE:
+      return Message_Hash(val.msg_val, type_info.def.msgdef, seed);
+    default:
+      rb_raise(rb_eRuntimeError, "Internal error, unexpected type");
+  }
+}

data/ext/google/protobuf_c/convert.h

@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef RUBY_PROTOBUF_CONVERT_H_
+#define RUBY_PROTOBUF_CONVERT_H_
+
+#include <ruby/ruby.h>
+
+#include "protobuf.h"
+#include "ruby-upb.h"
+
+// Converts |ruby_val| to a upb_msgval according to |type_info|.
+//
+// The |arena| parameter indicates the lifetime of the container where this
+// value will be assigned. It is used as follows:
+// - If type is string or bytes, the string data will be copied into |arena|.
+// - If type is message, and we need to auto-construct a message due to implicit
+//   conversions (eg. Time -> Google::Protobuf::Timestamp), the new message
+//   will be created in |arena|.
+// - If type is message and the Ruby value is a message instance, we will fuse
+//   the message's arena into |arena|, to ensure that this message outlives the
+//   container.
+upb_msgval Convert_RubyToUpb(VALUE ruby_val, const char *name,
+                             TypeInfo type_info, upb_arena *arena);
+
+// Converts |upb_val| to a Ruby VALUE according to |type_info|. This may involve
+// creating a Ruby wrapper object.
+//
+// The |arena| parameter indicates the arena that owns the lifetime of
+// |upb_val|. Any Ruby wrapper object that is created will reference |arena|
+// and ensure it outlives the wrapper.
+VALUE Convert_UpbToRuby(upb_msgval upb_val, TypeInfo type_info, VALUE arena);
+
+// Creates a deep copy of |msgval| in |arena|.
+upb_msgval Msgval_DeepCopy(upb_msgval msgval, TypeInfo type_info,
+                           upb_arena *arena);
+
+// Returns true if |val1| and |val2| are equal. Their type is given by
+// |type_info|.
+bool Msgval_IsEqual(upb_msgval val1, upb_msgval val2, TypeInfo type_info);
+
+// Returns a hash value for the given upb_msgval.
+uint64_t Msgval_GetHash(upb_msgval val, TypeInfo type_info, uint64_t seed);
+
+#endif  // RUBY_PROTOBUF_CONVERT_H_

data/ext/google/protobuf_c/defs.c

@@ -30,8 +30,35 @@
 
 #include <ctype.h>
 #include <errno.h>
+#include <ruby/version.h>
+
+#include "convert.h"
+#include "message.h"
 #include "protobuf.h"
 
+static VALUE Builder_build(VALUE _self);
+
+static VALUE cMessageBuilderContext;
+static VALUE cOneofBuilderContext;
+static VALUE cEnumBuilderContext;
+static VALUE cBuilder;
+
+// -----------------------------------------------------------------------------
+// Global map from upb {msg,enum}defs to wrapper Descriptor/EnumDescriptor
+// instances.
+// -----------------------------------------------------------------------------
+
+static VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_msgdef* def);
+static VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_enumdef* def);
+static VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_fielddef* def);
+static VALUE get_filedef_obj(VALUE descriptor_pool, const upb_filedef* def);
+static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_oneofdef* def);
+
+// A distinct object that is not accessible from Ruby.  We use this as a
+// constructor argument to enforce that certain objects cannot be created from
+// Ruby.
+VALUE c_only_cookie = Qnil;
+
 // -----------------------------------------------------------------------------
 // Common utilities.
 // -----------------------------------------------------------------------------
@@ -48,6 +75,10 @@ static VALUE rb_str_maybe_null(const char* s) {
   return rb_str_new2(s);
 }
 
+// -----------------------------------------------------------------------------
+// Backward compatibility code.
+// -----------------------------------------------------------------------------
+
 static void rewrite_enum_default(const upb_symtab* symtab,
                                  google_protobuf_FileDescriptorProto* file,
                                  google_protobuf_FieldDescriptorProto* field) {
@@ -205,221 +236,70 @@ static void rewrite_nesting(VALUE msg_ent, google_protobuf_DescriptorProto* msg,
   }
 }
 
-/* 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);
-}
-
 // -----------------------------------------------------------------------------
 // DescriptorPool.
 // -----------------------------------------------------------------------------
 
-#define DEFINE_CLASS(name, string_name)                             \
-    VALUE c ## name = Qnil;                                         \
-    const rb_data_type_t _ ## name ## _type = {                     \
-      string_name,                                                  \
-      { name ## _mark, name ## _free, NULL },                       \
-    };                                                              \
-    name* ruby_to_ ## name(VALUE val) {                             \
-      name* ret;                                                    \
-      TypedData_Get_Struct(val, name, &_ ## name ## _type, ret);    \
-      return ret;                                                   \
-    }                                                               \
-
-#define DEFINE_SELF(type, var, rb_var)                              \
-    type* var = ruby_to_ ## type(rb_var)
+typedef struct {
+  VALUE def_to_descriptor;  // Hash table of def* -> Ruby descriptor.
+  upb_symtab* symtab;
+} DescriptorPool;
+
+VALUE cDescriptorPool = Qnil;
 
 // Global singleton DescriptorPool. The user is free to create others, but this
 // is used by generated code.
 VALUE generated_pool = Qnil;
 
-DEFINE_CLASS(DescriptorPool, "Google::Protobuf::DescriptorPool");
-
-void DescriptorPool_mark(void* _self) {
+static void DescriptorPool_mark(void* _self) {
   DescriptorPool* self = _self;
   rb_gc_mark(self->def_to_descriptor);
 }
 
-void DescriptorPool_free(void* _self) {
+static 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);
 }
 
+static const rb_data_type_t DescriptorPool_type = {
+  "Google::Protobuf::DescriptorPool",
+  {DescriptorPool_mark, DescriptorPool_free, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static DescriptorPool* ruby_to_DescriptorPool(VALUE val) {
+  DescriptorPool* ret;
+  TypedData_Get_Struct(val, DescriptorPool, &DescriptorPool_type, ret);
+  return ret;
+}
+
+// Exposed to other modules in defs.h.
+const upb_symtab *DescriptorPool_GetSymtab(VALUE desc_pool_rb) {
+  DescriptorPool *pool = ruby_to_DescriptorPool(desc_pool_rb);
+  return pool->symtab;
+}
+
 /*
  * call-seq:
  *     DescriptorPool.new => pool
  *
  * Creates a new, empty, descriptor pool.
  */
-VALUE DescriptorPool_alloc(VALUE klass) {
+static VALUE DescriptorPool_alloc(VALUE klass) {
   DescriptorPool* self = ALLOC(DescriptorPool);
   VALUE ret;
 
   self->def_to_descriptor = Qnil;
-  ret = TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
+  ret = TypedData_Wrap_Struct(klass, &DescriptorPool_type, self);
 
   self->def_to_descriptor = rb_hash_new();
   self->symtab = upb_symtab_new();
-  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();
+  ObjectCache_Add(self->symtab, ret, _upb_symtab_arena(self->symtab));
 
   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, "build", DescriptorPool_build, -1);
-  rb_define_method(klass, "lookup", DescriptorPool_lookup, 1);
-  rb_define_singleton_method(klass, "generated_pool",
-                             DescriptorPool_generated_pool, 0);
-  rb_gc_register_address(&cDescriptorPool);
-  cDescriptorPool = klass;
-
-  rb_gc_register_address(&generated_pool);
-  generated_pool = rb_class_new_instance(0, NULL, klass);
-}
-
 /*
  * call-seq:
  *     DescriptorPool.build(&block)
@@ -430,7 +310,7 @@ void DescriptorPool_register(VALUE module) {
  * Builder#add_enum within the block as appropriate.  This is the recommended,
  * idiomatic way to define new message and enum types.
  */
-VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
+static VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
   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);
@@ -445,8 +325,8 @@ VALUE DescriptorPool_build(int argc, VALUE* argv, VALUE _self) {
  * Finds a Descriptor or EnumDescriptor by name and returns it, or nil if none
  * exists with the given name.
  */
-VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
-  DEFINE_SELF(DescriptorPool, self, _self);
+static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
+  DescriptorPool* self = ruby_to_DescriptorPool(_self);
   const char* name_str = get_str(name);
   const upb_msgdef* msgdef;
   const upb_enumdef* enumdef;
@@ -473,31 +353,53 @@ VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
  * register types in this pool for convenience so that they do not have to hold
  * a reference to a private pool instance.
  */
-VALUE DescriptorPool_generated_pool(VALUE _self) {
+static VALUE DescriptorPool_generated_pool(VALUE _self) {
   return generated_pool;
 }
 
+static 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, "build", DescriptorPool_build, -1);
+  rb_define_method(klass, "lookup", DescriptorPool_lookup, 1);
+  rb_define_singleton_method(klass, "generated_pool",
+                             DescriptorPool_generated_pool, 0);
+  rb_gc_register_address(&cDescriptorPool);
+  cDescriptorPool = klass;
+
+  rb_gc_register_address(&generated_pool);
+  generated_pool = rb_class_new_instance(0, NULL, klass);
+}
+
 // -----------------------------------------------------------------------------
 // Descriptor.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(Descriptor, "Google::Protobuf::Descriptor");
+typedef struct {
+  const upb_msgdef* msgdef;
+  VALUE klass;
+  VALUE descriptor_pool;
+} Descriptor;
+
+VALUE cDescriptor = Qnil;
 
-void Descriptor_mark(void* _self) {
+static 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;
-  if (self->layout) {
-    free_layout(self->layout);
-  }
-  xfree(self);
+static const rb_data_type_t Descriptor_type = {
+  "Google::Protobuf::Descriptor",
+  {Descriptor_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static Descriptor* ruby_to_Descriptor(VALUE val) {
+  Descriptor* ret;
+  TypedData_Get_Struct(val, Descriptor, &Descriptor_type, ret);
+  return ret;
 }
 
 /*
@@ -509,42 +411,24 @@ void Descriptor_free(void* _self) {
  * it is added to a pool, after which it becomes immutable (as part of a
  * finalization process).
  */
-VALUE Descriptor_alloc(VALUE klass) {
+static VALUE Descriptor_alloc(VALUE klass) {
   Descriptor* self = ALLOC(Descriptor);
-  VALUE ret = TypedData_Wrap_Struct(klass, &_Descriptor_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &Descriptor_type, self);
   self->msgdef = NULL;
   self->klass = Qnil;
   self->descriptor_pool = Qnil;
-  self->layout = NULL;
   return ret;
 }
 
-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, 3);
-  rb_define_method(klass, "each", Descriptor_each, 0);
-  rb_define_method(klass, "lookup", Descriptor_lookup, 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, "file_descriptor", Descriptor_file_descriptor, 0);
-  rb_include_module(klass, rb_mEnumerable);
-  rb_gc_register_address(&cDescriptor);
-  cDescriptor = klass;
-}
-
 /*
  * call-seq:
  *    Descriptor.new(c_only_cookie, ptr) => Descriptor
  *
  * Creates a descriptor wrapper object.  May only be called from C.
  */
-VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
-                            VALUE descriptor_pool, VALUE ptr) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
+                                   VALUE descriptor_pool, VALUE ptr) {
+  Descriptor* self = ruby_to_Descriptor(_self);
 
   if (cookie != c_only_cookie) {
     rb_raise(rb_eRuntimeError,
@@ -563,8 +447,8 @@ VALUE Descriptor_initialize(VALUE _self, VALUE cookie,
  *
  * Returns the FileDescriptor object this message belongs to.
  */
-VALUE Descriptor_file_descriptor(VALUE _self) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_file_descriptor(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
   return get_filedef_obj(self->descriptor_pool, upb_msgdef_file(self->msgdef));
 }
 
@@ -575,8 +459,8 @@ VALUE Descriptor_file_descriptor(VALUE _self) {
  * Returns the name of this message type as a fully-qualified string (e.g.,
  * My.Package.MessageType).
  */
-VALUE Descriptor_name(VALUE _self) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_name(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
   return rb_str_maybe_null(upb_msgdef_fullname(self->msgdef));
 }
 
@@ -586,8 +470,8 @@ VALUE Descriptor_name(VALUE _self) {
  *
  * Iterates over fields in this message type, yielding to the block on each one.
  */
-VALUE Descriptor_each(VALUE _self) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_each(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
 
   upb_msg_field_iter it;
   for (upb_msg_field_begin(&it, self->msgdef);
@@ -607,8 +491,8 @@ VALUE Descriptor_each(VALUE _self) {
  * Returns the field descriptor for the field with the given name, if present,
  * or nil if none.
  */
-VALUE Descriptor_lookup(VALUE _self, VALUE name) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_lookup(VALUE _self, VALUE name) {
+  Descriptor* self = ruby_to_Descriptor(_self);
   const char* s = get_str(name);
   const upb_fielddef* field = upb_msgdef_ntofz(self->msgdef, s);
   if (field == NULL) {
@@ -624,8 +508,8 @@ VALUE Descriptor_lookup(VALUE _self, VALUE name) {
  * Invokes the given block for each oneof in this message type, passing the
  * corresponding OneofDescriptor.
  */
-VALUE Descriptor_each_oneof(VALUE _self) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_each_oneof(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
 
   upb_msg_oneof_iter it;
   for (upb_msg_oneof_begin(&it, self->msgdef);
@@ -645,8 +529,8 @@ VALUE Descriptor_each_oneof(VALUE _self) {
  * Returns the oneof descriptor for the oneof with the given name, if present,
  * or nil if none.
  */
-VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
+  Descriptor* self = ruby_to_Descriptor(_self);
   const char* s = get_str(name);
   const upb_oneofdef* oneof = upb_msgdef_ntooz(self->msgdef, s);
   if (oneof == NULL) {
@@ -661,32 +545,62 @@ VALUE Descriptor_lookup_oneof(VALUE _self, VALUE name) {
  *
  * Returns the Ruby class created for this message type.
  */
-VALUE Descriptor_msgclass(VALUE _self) {
-  DEFINE_SELF(Descriptor, self, _self);
+static VALUE Descriptor_msgclass(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
   if (self->klass == Qnil) {
     self->klass = build_class_from_descriptor(_self);
   }
   return self->klass;
 }
 
+static 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, 3);
+  rb_define_method(klass, "each", Descriptor_each, 0);
+  rb_define_method(klass, "lookup", Descriptor_lookup, 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, "file_descriptor", Descriptor_file_descriptor, 0);
+  rb_include_module(klass, rb_mEnumerable);
+  rb_gc_register_address(&cDescriptor);
+  cDescriptor = klass;
+}
+
 // -----------------------------------------------------------------------------
 // FileDescriptor.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(FileDescriptor, "Google::Protobuf::FileDescriptor");
+typedef struct {
+  const upb_filedef* filedef;
+  VALUE descriptor_pool;  // Owns the upb_filedef.
+} FileDescriptor;
 
-void FileDescriptor_mark(void* _self) {
+static VALUE cFileDescriptor = Qnil;
+
+static void FileDescriptor_mark(void* _self) {
   FileDescriptor* self = _self;
   rb_gc_mark(self->descriptor_pool);
 }
 
-void FileDescriptor_free(void* _self) {
-  xfree(_self);
+static const rb_data_type_t FileDescriptor_type = {
+  "Google::Protobuf::FileDescriptor",
+  {FileDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static FileDescriptor* ruby_to_FileDescriptor(VALUE val) {
+  FileDescriptor* ret;
+  TypedData_Get_Struct(val, FileDescriptor, &FileDescriptor_type, ret);
+  return ret;
 }
 
-VALUE FileDescriptor_alloc(VALUE klass) {
+static VALUE FileDescriptor_alloc(VALUE klass) {
   FileDescriptor* self = ALLOC(FileDescriptor);
-  VALUE ret = TypedData_Wrap_Struct(klass, &_FileDescriptor_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &FileDescriptor_type, self);
   self->descriptor_pool = Qnil;
   self->filedef = NULL;
   return ret;
@@ -699,9 +613,9 @@ VALUE FileDescriptor_alloc(VALUE klass) {
  * Returns a new file descriptor. The syntax must be set before it's passed
  * to a builder.
  */
-VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
+static VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
                                 VALUE descriptor_pool, VALUE ptr) {
-  DEFINE_SELF(FileDescriptor, self, _self);
+  FileDescriptor* self = ruby_to_FileDescriptor(_self);
 
   if (cookie != c_only_cookie) {
     rb_raise(rb_eRuntimeError,
@@ -714,25 +628,14 @@ VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
   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, 3);
-  rb_define_method(klass, "name", FileDescriptor_name, 0);
-  rb_define_method(klass, "syntax", FileDescriptor_syntax, 0);
-  rb_gc_register_address(&cFileDescriptor);
-  cFileDescriptor = klass;
-}
-
 /*
  * call-seq:
  *     FileDescriptor.name => name
  *
  * Returns the name of the file.
  */
-VALUE FileDescriptor_name(VALUE _self) {
-  DEFINE_SELF(FileDescriptor, self, _self);
+static VALUE FileDescriptor_name(VALUE _self) {
+  FileDescriptor* self = ruby_to_FileDescriptor(_self);
   const char* name = upb_filedef_name(self->filedef);
   return name == NULL ? Qnil : rb_str_new2(name);
 }
@@ -746,8 +649,8 @@ VALUE FileDescriptor_name(VALUE _self) {
  * Valid syntax versions are:
  *     :proto2 or :proto3.
  */
-VALUE FileDescriptor_syntax(VALUE _self) {
-  DEFINE_SELF(FileDescriptor, self, _self);
+static VALUE FileDescriptor_syntax(VALUE _self) {
+  FileDescriptor* self = ruby_to_FileDescriptor(_self);
 
   switch (upb_filedef_syntax(self->filedef)) {
     case UPB_SYNTAX_PROTO3: return ID2SYM(rb_intern("proto3"));
@@ -756,19 +659,43 @@ VALUE FileDescriptor_syntax(VALUE _self) {
   }
 }
 
+static void FileDescriptor_register(VALUE module) {
+  VALUE klass = rb_define_class_under(
+      module, "FileDescriptor", rb_cObject);
+  rb_define_alloc_func(klass, FileDescriptor_alloc);
+  rb_define_method(klass, "initialize", FileDescriptor_initialize, 3);
+  rb_define_method(klass, "name", FileDescriptor_name, 0);
+  rb_define_method(klass, "syntax", FileDescriptor_syntax, 0);
+  rb_gc_register_address(&cFileDescriptor);
+  cFileDescriptor = klass;
+}
+
 // -----------------------------------------------------------------------------
 // FieldDescriptor.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(FieldDescriptor, "Google::Protobuf::FieldDescriptor");
+typedef struct {
+  const upb_fielddef* fielddef;
+  VALUE descriptor_pool;  // Owns the upb_fielddef.
+} FieldDescriptor;
+
+static VALUE cFieldDescriptor = Qnil;
 
-void FieldDescriptor_mark(void* _self) {
+static void FieldDescriptor_mark(void* _self) {
   FieldDescriptor* self = _self;
   rb_gc_mark(self->descriptor_pool);
 }
 
-void FieldDescriptor_free(void* _self) {
-  xfree(_self);
+static const rb_data_type_t FieldDescriptor_type = {
+  "Google::Protobuf::FieldDescriptor",
+  {FieldDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static FieldDescriptor* ruby_to_FieldDescriptor(VALUE val) {
+  FieldDescriptor* ret;
+  TypedData_Get_Struct(val, FieldDescriptor, &FieldDescriptor_type, ret);
+  return ret;
 }
 
 /*
@@ -778,42 +705,22 @@ void FieldDescriptor_free(void* _self) {
  * Returns a new field descriptor. Its name, type, etc. must be set before it is
  * added to a message type.
  */
-VALUE FieldDescriptor_alloc(VALUE klass) {
+static VALUE FieldDescriptor_alloc(VALUE klass) {
   FieldDescriptor* self = ALLOC(FieldDescriptor);
-  VALUE ret = TypedData_Wrap_Struct(klass, &_FieldDescriptor_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &FieldDescriptor_type, self);
   self->fielddef = NULL;
   return ret;
 }
 
-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, "type", FieldDescriptor_type, 0);
-  rb_define_method(klass, "default", FieldDescriptor_default, 0);
-  rb_define_method(klass, "label", FieldDescriptor_label, 0);
-  rb_define_method(klass, "number", FieldDescriptor_number, 0);
-  rb_define_method(klass, "submsg_name", FieldDescriptor_submsg_name, 0);
-  rb_define_method(klass, "subtype", FieldDescriptor_subtype, 0);
-  rb_define_method(klass, "has?", FieldDescriptor_has, 1);
-  rb_define_method(klass, "clear", FieldDescriptor_clear, 1);
-  rb_define_method(klass, "get", FieldDescriptor_get, 1);
-  rb_define_method(klass, "set", FieldDescriptor_set, 2);
-  rb_gc_register_address(&cFieldDescriptor);
-  cFieldDescriptor = klass;
-}
-
 /*
  * call-seq:
  *    EnumDescriptor.new(c_only_cookie, pool, ptr) => EnumDescriptor
  *
  * Creates a descriptor wrapper object.  May only be called from C.
  */
-VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
-                                 VALUE descriptor_pool, VALUE ptr) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
+static VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
+                                        VALUE descriptor_pool, VALUE ptr) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
 
   if (cookie != c_only_cookie) {
     rb_raise(rb_eRuntimeError,
@@ -832,11 +739,12 @@ VALUE FieldDescriptor_initialize(VALUE _self, VALUE cookie,
  *
  * Returns the name of this field.
  */
-VALUE FieldDescriptor_name(VALUE _self) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
+static VALUE FieldDescriptor_name(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   return rb_str_maybe_null(upb_fielddef_name(self->fielddef));
 }
 
+// Non-static, exposed to other .c files.
 upb_fieldtype_t ruby_to_fieldtype(VALUE type) {
   if (TYPE(type) != T_SYMBOL) {
     rb_raise(rb_eArgError, "Expected symbol for field type.");
@@ -865,27 +773,7 @@ upb_fieldtype_t ruby_to_fieldtype(VALUE type) {
   return 0;
 }
 
-VALUE fieldtype_to_ruby(upb_fieldtype_t type) {
-  switch (type) {
-#define CONVERT(upb, ruby)                                           \
-    case UPB_TYPE_ ## upb : return ID2SYM(rb_intern( # ruby ));
-    CONVERT(FLOAT, float);
-    CONVERT(DOUBLE, double);
-    CONVERT(BOOL, bool);
-    CONVERT(STRING, string);
-    CONVERT(BYTES, bytes);
-    CONVERT(MESSAGE, message);
-    CONVERT(ENUM, enum);
-    CONVERT(INT32, int32);
-    CONVERT(INT64, int64);
-    CONVERT(UINT32, uint32);
-    CONVERT(UINT64, uint64);
-#undef CONVERT
-  }
-  return Qnil;
-}
-
-upb_descriptortype_t ruby_to_descriptortype(VALUE type) {
+static upb_descriptortype_t ruby_to_descriptortype(VALUE type) {
   if (TYPE(type) != T_SYMBOL) {
     rb_raise(rb_eArgError, "Expected symbol for field type.");
   }
@@ -920,7 +808,7 @@ upb_descriptortype_t ruby_to_descriptortype(VALUE type) {
   return 0;
 }
 
-VALUE descriptortype_to_ruby(upb_descriptortype_t type) {
+static VALUE descriptortype_to_ruby(upb_descriptortype_t type) {
   switch (type) {
 #define CONVERT(upb, ruby)                                           \
     case UPB_DESCRIPTOR_TYPE_ ## upb : return ID2SYM(rb_intern( # ruby ));
@@ -947,29 +835,6 @@ 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
@@ -980,8 +845,8 @@ VALUE ruby_to_label(VALUE label) {
  *     :int32, :int64, :uint32, :uint64, :float, :double, :bool, :string,
  *     :bytes, :message.
  */
-VALUE FieldDescriptor_type(VALUE _self) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
+static VALUE FieldDescriptor__type(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   return descriptortype_to_ruby(upb_fielddef_descriptortype(self->fielddef));
 }
 
@@ -991,9 +856,16 @@ VALUE FieldDescriptor_type(VALUE _self) {
  *
  * Returns this field's default, as a Ruby object, or nil if not yet set.
  */
-VALUE FieldDescriptor_default(VALUE _self) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  return layout_get_default(self->fielddef);
+static VALUE FieldDescriptor_default(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  const upb_fielddef *f = self->fielddef;
+  upb_msgval default_val = {0};
+  if (upb_fielddef_issubmsg(f)) {
+    return Qnil;
+  } else if (!upb_fielddef_isseq(f)) {
+    default_val = upb_fielddef_default(f);
+  }
+  return Convert_UpbToRuby(default_val, TypeInfo_get(self->fielddef), Qnil);
 }
 
 /*
@@ -1005,8 +877,8 @@ VALUE FieldDescriptor_default(VALUE _self) {
  * Valid field labels are:
  *     :optional, :repeated
  */
-VALUE FieldDescriptor_label(VALUE _self) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
+static VALUE FieldDescriptor_label(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   switch (upb_fielddef_label(self->fielddef)) {
 #define CONVERT(upb, ruby)                                           \
     case UPB_LABEL_ ## upb : return ID2SYM(rb_intern( # ruby ));
@@ -1027,8 +899,8 @@ VALUE FieldDescriptor_label(VALUE _self) {
  *
  * Returns the tag number for this field.
  */
-VALUE FieldDescriptor_number(VALUE _self) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
+static VALUE FieldDescriptor_number(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   return INT2NUM(upb_fielddef_number(self->fielddef));
 }
 
@@ -1041,8 +913,8 @@ VALUE FieldDescriptor_number(VALUE _self) {
  * name will be resolved within the context of the pool to which the containing
  * message type is added.
  */
-VALUE FieldDescriptor_submsg_name(VALUE _self) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
+static VALUE FieldDescriptor_submsg_name(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   switch (upb_fielddef_type(self->fielddef)) {
     case UPB_TYPE_ENUM:
       return rb_str_new2(
@@ -1064,8 +936,8 @@ VALUE FieldDescriptor_submsg_name(VALUE _self) {
  * called *until* the containing message type is added to a pool (and thus
  * resolved).
  */
-VALUE FieldDescriptor_subtype(VALUE _self) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
+static VALUE FieldDescriptor_subtype(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   switch (upb_fielddef_type(self->fielddef)) {
     case UPB_TYPE_ENUM:
       return get_enumdef_obj(self->descriptor_pool,
@@ -1085,14 +957,19 @@ VALUE FieldDescriptor_subtype(VALUE _self) {
  * Returns the value set for this field on the given message. Raises an
  * exception if message is of the wrong type.
  */
-VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  MessageHeader* msg;
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-  if (msg->descriptor->msgdef != upb_fielddef_containingtype(self->fielddef)) {
+static VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  const upb_msgdef *m;
+  const upb_msgdef *msg = Message_Get(msg_rb, &m);
+  VALUE arena = Message_GetArena(msg_rb);
+  upb_msgval msgval;
+
+  if (m != upb_fielddef_containingtype(self->fielddef)) {
     rb_raise(cTypeError, "get method called on wrong message type");
   }
-  return layout_get(msg->descriptor->layout, Message_data(msg), self->fielddef);
+
+  msgval = upb_msg_get(msg, self->fielddef);
+  return Convert_UpbToRuby(msgval, TypeInfo_get(self->fielddef), arena);
 }
 
 /*
@@ -1102,17 +979,18 @@ VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
  * Returns whether the value is set on the given message. Raises an
  * exception when calling for fields that do not have presence.
  */
-VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  MessageHeader* msg;
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-  if (msg->descriptor->msgdef != upb_fielddef_containingtype(self->fielddef)) {
+static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  const upb_msgdef *m;
+  const upb_msgdef *msg = Message_Get(msg_rb, &m);
+
+  if (m != upb_fielddef_containingtype(self->fielddef)) {
     rb_raise(cTypeError, "has method called on wrong message type");
   } else if (!upb_fielddef_haspresence(self->fielddef)) {
     rb_raise(rb_eArgError, "does not track presence");
   }
 
-  return layout_has(msg->descriptor->layout, Message_data(msg), self->fielddef);
+  return upb_msg_has(msg, self->fielddef) ? Qtrue : Qfalse;
 }
 
 /*
@@ -1121,15 +999,16 @@ VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
  *
  * Clears the field from the message if it's set.
  */
-VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  MessageHeader* msg;
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-  if (msg->descriptor->msgdef != upb_fielddef_containingtype(self->fielddef)) {
+static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  const upb_msgdef *m;
+  upb_msgdef *msg = Message_GetMutable(msg_rb, &m);
+
+  if (m != upb_fielddef_containingtype(self->fielddef)) {
     rb_raise(cTypeError, "has method called on wrong message type");
   }
 
-  layout_clear(msg->descriptor->layout, Message_data(msg), self->fielddef);
+  upb_msg_clearfield(msg, self->fielddef);
   return Qnil;
 }
 
@@ -1141,30 +1020,69 @@ VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
  * message. Raises an exception if message is of the wrong type. Performs the
  * ordinary type-checks for field setting.
  */
-VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
-  DEFINE_SELF(FieldDescriptor, self, _self);
-  MessageHeader* msg;
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-  if (msg->descriptor->msgdef != upb_fielddef_containingtype(self->fielddef)) {
+static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  const upb_msgdef *m;
+  upb_msgdef *msg = Message_GetMutable(msg_rb, &m);
+  upb_arena *arena = Arena_get(Message_GetArena(msg_rb));
+  upb_msgval msgval;
+
+  if (m != upb_fielddef_containingtype(self->fielddef)) {
     rb_raise(cTypeError, "set method called on wrong message type");
   }
-  layout_set(msg->descriptor->layout, Message_data(msg), self->fielddef, value);
+
+  msgval = Convert_RubyToUpb(value, upb_fielddef_name(self->fielddef),
+                             TypeInfo_get(self->fielddef), arena);
+  upb_msg_set(msg, self->fielddef, msgval, arena);
   return Qnil;
 }
 
+static 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, "type", FieldDescriptor__type, 0);
+  rb_define_method(klass, "default", FieldDescriptor_default, 0);
+  rb_define_method(klass, "label", FieldDescriptor_label, 0);
+  rb_define_method(klass, "number", FieldDescriptor_number, 0);
+  rb_define_method(klass, "submsg_name", FieldDescriptor_submsg_name, 0);
+  rb_define_method(klass, "subtype", FieldDescriptor_subtype, 0);
+  rb_define_method(klass, "has?", FieldDescriptor_has, 1);
+  rb_define_method(klass, "clear", FieldDescriptor_clear, 1);
+  rb_define_method(klass, "get", FieldDescriptor_get, 1);
+  rb_define_method(klass, "set", FieldDescriptor_set, 2);
+  rb_gc_register_address(&cFieldDescriptor);
+  cFieldDescriptor = klass;
+}
+
 // -----------------------------------------------------------------------------
 // OneofDescriptor.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(OneofDescriptor, "Google::Protobuf::OneofDescriptor");
+typedef struct {
+  const upb_oneofdef* oneofdef;
+  VALUE descriptor_pool;  // Owns the upb_oneofdef.
+} OneofDescriptor;
+
+static VALUE cOneofDescriptor = Qnil;
 
-void OneofDescriptor_mark(void* _self) {
+static void OneofDescriptor_mark(void* _self) {
   OneofDescriptor* self = _self;
   rb_gc_mark(self->descriptor_pool);
 }
 
-void OneofDescriptor_free(void* _self) {
-  xfree(_self);
+static const rb_data_type_t OneofDescriptor_type = {
+    "Google::Protobuf::OneofDescriptor",
+    {OneofDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static OneofDescriptor* ruby_to_OneofDescriptor(VALUE val) {
+  OneofDescriptor* ret;
+  TypedData_Get_Struct(val, OneofDescriptor, &OneofDescriptor_type, ret);
+  return ret;
 }
 
 /*
@@ -1174,35 +1092,23 @@ void OneofDescriptor_free(void* _self) {
  * Creates a new, empty, oneof descriptor. The oneof may only be modified prior
  * to being added to a message descriptor which is subsequently added to a pool.
  */
-VALUE OneofDescriptor_alloc(VALUE klass) {
+static VALUE OneofDescriptor_alloc(VALUE klass) {
   OneofDescriptor* self = ALLOC(OneofDescriptor);
-  VALUE ret = TypedData_Wrap_Struct(klass, &_OneofDescriptor_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &OneofDescriptor_type, self);
   self->oneofdef = NULL;
   self->descriptor_pool = Qnil;
   return ret;
 }
 
-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, "each", OneofDescriptor_each, 0);
-  rb_include_module(klass, rb_mEnumerable);
-  rb_gc_register_address(&cOneofDescriptor);
-  cOneofDescriptor = klass;
-}
-
 /*
  * call-seq:
  *    OneofDescriptor.new(c_only_cookie, pool, ptr) => OneofDescriptor
  *
  * Creates a descriptor wrapper object.  May only be called from C.
  */
-VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
+static VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
                                  VALUE descriptor_pool, VALUE ptr) {
-  DEFINE_SELF(OneofDescriptor, self, _self);
+  OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
 
   if (cookie != c_only_cookie) {
     rb_raise(rb_eRuntimeError,
@@ -1221,8 +1127,8 @@ VALUE OneofDescriptor_initialize(VALUE _self, VALUE cookie,
  *
  * Returns the name of this oneof.
  */
-VALUE OneofDescriptor_name(VALUE _self) {
-  DEFINE_SELF(OneofDescriptor, self, _self);
+static VALUE OneofDescriptor_name(VALUE _self) {
+  OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
   return rb_str_maybe_null(upb_oneofdef_name(self->oneofdef));
 }
 
@@ -1232,8 +1138,8 @@ VALUE OneofDescriptor_name(VALUE _self) {
  *
  * Iterates through fields in this oneof, yielding to the block on each one.
  */
-VALUE OneofDescriptor_each(VALUE _self) {
-  DEFINE_SELF(OneofDescriptor, self, _self);
+static VALUE OneofDescriptor_each(VALUE _self) {
+  OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
   upb_oneof_iter it;
   for (upb_oneof_begin(&it, self->oneofdef);
        !upb_oneof_done(&it);
@@ -1245,40 +1151,72 @@ VALUE OneofDescriptor_each(VALUE _self) {
   return Qnil;
 }
 
+static 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, "each", OneofDescriptor_each, 0);
+  rb_include_module(klass, rb_mEnumerable);
+  rb_gc_register_address(&cOneofDescriptor);
+  cOneofDescriptor = klass;
+}
+
 // -----------------------------------------------------------------------------
 // EnumDescriptor.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(EnumDescriptor, "Google::Protobuf::EnumDescriptor");
+typedef struct {
+  const upb_enumdef* enumdef;
+  VALUE module;  // begins as nil
+  VALUE descriptor_pool;  // Owns the upb_enumdef.
+} EnumDescriptor;
+
+static VALUE cEnumDescriptor = Qnil;
 
-void EnumDescriptor_mark(void* _self) {
+static void EnumDescriptor_mark(void* _self) {
   EnumDescriptor* self = _self;
   rb_gc_mark(self->module);
   rb_gc_mark(self->descriptor_pool);
 }
 
-void EnumDescriptor_free(void* _self) {
-  xfree(_self);
+static const rb_data_type_t EnumDescriptor_type = {
+  "Google::Protobuf::EnumDescriptor",
+  {EnumDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static EnumDescriptor* ruby_to_EnumDescriptor(VALUE val) {
+  EnumDescriptor* ret;
+  TypedData_Get_Struct(val, EnumDescriptor, &EnumDescriptor_type, ret);
+  return ret;
 }
 
-VALUE EnumDescriptor_alloc(VALUE klass) {
+static VALUE EnumDescriptor_alloc(VALUE klass) {
   EnumDescriptor* self = ALLOC(EnumDescriptor);
-  VALUE ret = TypedData_Wrap_Struct(klass, &_EnumDescriptor_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &EnumDescriptor_type, self);
   self->enumdef = NULL;
   self->module = Qnil;
   self->descriptor_pool = Qnil;
   return ret;
 }
 
+// Exposed to other modules in defs.h.
+const upb_enumdef *EnumDescriptor_GetEnumDef(VALUE enum_desc_rb) {
+  EnumDescriptor *desc = ruby_to_EnumDescriptor(enum_desc_rb);
+  return desc->enumdef;
+}
+
 /*
  * 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);
+static VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
+                                       VALUE descriptor_pool, VALUE ptr) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
 
   if (cookie != c_only_cookie) {
     rb_raise(rb_eRuntimeError,
@@ -1291,30 +1229,14 @@ VALUE EnumDescriptor_initialize(VALUE _self, VALUE cookie,
   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, 3);
-  rb_define_method(klass, "name", EnumDescriptor_name, 0);
-  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);
-  rb_define_method(klass, "enummodule", EnumDescriptor_enummodule, 0);
-  rb_define_method(klass, "file_descriptor", EnumDescriptor_file_descriptor, 0);
-  rb_include_module(klass, rb_mEnumerable);
-  rb_gc_register_address(&cEnumDescriptor);
-  cEnumDescriptor = klass;
-}
-
 /*
  * call-seq:
  *    EnumDescriptor.file_descriptor
  *
  * Returns the FileDescriptor object this enum belongs to.
  */
-VALUE EnumDescriptor_file_descriptor(VALUE _self) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
+static VALUE EnumDescriptor_file_descriptor(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   return get_filedef_obj(self->descriptor_pool,
                          upb_enumdef_file(self->enumdef));
 }
@@ -1325,8 +1247,8 @@ VALUE EnumDescriptor_file_descriptor(VALUE _self) {
  *
  * Returns the name of this enum type.
  */
-VALUE EnumDescriptor_name(VALUE _self) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
+static VALUE EnumDescriptor_name(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   return rb_str_maybe_null(upb_enumdef_fullname(self->enumdef));
 }
 
@@ -1337,8 +1259,8 @@ VALUE EnumDescriptor_name(VALUE _self) {
  * Returns the numeric value corresponding to the given key name (as a Ruby
  * symbol), or nil if none.
  */
-VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
+static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   const char* name_str= rb_id2name(SYM2ID(name));
   int32_t val = 0;
   if (upb_enumdef_ntoiz(self->enumdef, name_str, &val)) {
@@ -1355,8 +1277,8 @@ VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
  * Returns the key name (as a Ruby symbol) corresponding to the integer value,
  * or nil if none.
  */
-VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
+static VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   int32_t val = NUM2INT(number);
   const char* name = upb_enumdef_iton(self->enumdef, val);
   if (name != NULL) {
@@ -1373,8 +1295,8 @@ VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
  * Iterates over key => value mappings in this enum's definition, yielding to
  * the block with (key, value) arguments for each one.
  */
-VALUE EnumDescriptor_each(VALUE _self) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
+static VALUE EnumDescriptor_each(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
 
   upb_enum_iter it;
   for (upb_enum_begin(&it, self->enumdef);
@@ -1394,53 +1316,365 @@ VALUE EnumDescriptor_each(VALUE _self) {
  *
  * Returns the Ruby module corresponding to this enum type.
  */
-VALUE EnumDescriptor_enummodule(VALUE _self) {
-  DEFINE_SELF(EnumDescriptor, self, _self);
+static VALUE EnumDescriptor_enummodule(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   if (self->module == Qnil) {
     self->module = build_module_from_enumdesc(_self);
   }
   return self->module;
 }
 
+static 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, 3);
+  rb_define_method(klass, "name", EnumDescriptor_name, 0);
+  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);
+  rb_define_method(klass, "enummodule", EnumDescriptor_enummodule, 0);
+  rb_define_method(klass, "file_descriptor", EnumDescriptor_file_descriptor, 0);
+  rb_include_module(klass, rb_mEnumerable);
+  rb_gc_register_address(&cEnumDescriptor);
+  cEnumDescriptor = klass;
+}
+
+// -----------------------------------------------------------------------------
+// FileBuilderContext.
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  upb_arena *arena;
+  google_protobuf_FileDescriptorProto* file_proto;
+  VALUE descriptor_pool;
+} FileBuilderContext;
+
+static VALUE cFileBuilderContext = Qnil;
+
+static void FileBuilderContext_mark(void* _self) {
+  FileBuilderContext* self = _self;
+  rb_gc_mark(self->descriptor_pool);
+}
+
+static void FileBuilderContext_free(void* _self) {
+  FileBuilderContext* self = _self;
+  upb_arena_free(self->arena);
+  xfree(self);
+}
+
+static const rb_data_type_t FileBuilderContext_type = {
+  "Google::Protobuf::Internal::FileBuilderContext",
+  {FileBuilderContext_mark, FileBuilderContext_free, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static FileBuilderContext* ruby_to_FileBuilderContext(VALUE val) {
+  FileBuilderContext* ret;
+  TypedData_Get_Struct(val, FileBuilderContext, &FileBuilderContext_type, ret);
+  return ret;
+}
+
+static upb_strview FileBuilderContext_strdup2(VALUE _self, const char *str) {
+  FileBuilderContext* self = ruby_to_FileBuilderContext(_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;
+}
+
+static upb_strview FileBuilderContext_strdup(VALUE _self, VALUE rb_str) {
+  return FileBuilderContext_strdup2(_self, get_str(rb_str));
+}
+
+static 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)));
+}
+
+static VALUE FileBuilderContext_alloc(VALUE klass) {
+  FileBuilderContext* self = ALLOC(FileBuilderContext);
+  VALUE ret = TypedData_Wrap_Struct(klass, &FileBuilderContext_type, self);
+  self->arena = upb_arena_new();
+  self->file_proto = google_protobuf_FileDescriptorProto_new(self->arena);
+  self->descriptor_pool = Qnil;
+  return ret;
+}
+
+/*
+ * call-seq:
+ *     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.
+ */
+static VALUE FileBuilderContext_initialize(VALUE _self, VALUE descriptor_pool,
+                                           VALUE name, VALUE options) {
+  FileBuilderContext* self = ruby_to_FileBuilderContext(_self);
+  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;
+}
+
+static void MessageBuilderContext_add_synthetic_oneofs(VALUE _self);
+
+/*
+ * call-seq:
+ *     FileBuilderContext.add_message(name, &block)
+ *
+ * Creates a new, empty descriptor with the given name, and invokes the block in
+ * the context of a MessageBuilderContext on that descriptor. The block can then
+ * call, e.g., MessageBuilderContext#optional and MessageBuilderContext#repeated
+ * methods to define the message fields.
+ *
+ * This is the recommended, idiomatic way to build message definitions.
+ */
+static VALUE FileBuilderContext_add_message(VALUE _self, VALUE name) {
+  VALUE args[2] = { _self, name };
+  VALUE ctx = rb_class_new_instance(2, args, cMessageBuilderContext);
+  VALUE block = rb_block_proc();
+  rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
+  MessageBuilderContext_add_synthetic_oneofs(ctx);
+  return Qnil;
+}
+
+/* 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);
+}
+
+/*
+ * call-seq:
+ *     FileBuilderContext.add_enum(name, &block)
+ *
+ * Creates a new, empty enum descriptor with the given name, and invokes the
+ * block in the context of an EnumBuilderContext on that descriptor. The block
+ * can then call EnumBuilderContext#add_value to define the enum values.
+ *
+ * This is the recommended, idiomatic way to build enum definitions.
+ */
+static VALUE FileBuilderContext_add_enum(VALUE _self, VALUE name) {
+  VALUE args[2] = { _self, name };
+  VALUE ctx = rb_class_new_instance(2, args, cEnumBuilderContext);
+  VALUE block = rb_block_proc();
+  rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
+  return Qnil;
+}
+
+static void FileBuilderContext_build(VALUE _self) {
+  FileBuilderContext* self = ruby_to_FileBuilderContext(_self);
+  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));
+  }
+}
+
+static 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, 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);
+  cFileBuilderContext = klass;
+}
+
 // -----------------------------------------------------------------------------
 // MessageBuilderContext.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(MessageBuilderContext,
-    "Google::Protobuf::Internal::MessageBuilderContext");
+typedef struct {
+  google_protobuf_DescriptorProto* msg_proto;
+  VALUE file_builder;
+} MessageBuilderContext;
+
+static VALUE cMessageBuilderContext = Qnil;
 
-void MessageBuilderContext_mark(void* _self) {
+static void MessageBuilderContext_mark(void* _self) {
   MessageBuilderContext* self = _self;
   rb_gc_mark(self->file_builder);
 }
 
-void MessageBuilderContext_free(void* _self) {
-  MessageBuilderContext* self = _self;
-  xfree(self);
-}
+static const rb_data_type_t MessageBuilderContext_type = {
+  "Google::Protobuf::Internal::MessageBuilderContext",
+  {MessageBuilderContext_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
-VALUE MessageBuilderContext_alloc(VALUE klass) {
-  MessageBuilderContext* self = ALLOC(MessageBuilderContext);
-  VALUE ret = TypedData_Wrap_Struct(
-      klass, &_MessageBuilderContext_type, self);
-  self->file_builder = Qnil;
+static MessageBuilderContext* ruby_to_MessageBuilderContext(VALUE val) {
+  MessageBuilderContext* ret;
+  TypedData_Get_Struct(val, MessageBuilderContext, &MessageBuilderContext_type,
+                       ret);
   return ret;
 }
 
-void MessageBuilderContext_register(VALUE module) {
-  VALUE klass = rb_define_class_under(
-      module, "MessageBuilderContext", rb_cObject);
-  rb_define_alloc_func(klass, MessageBuilderContext_alloc);
-  rb_define_method(klass, "initialize",
-                   MessageBuilderContext_initialize, 2);
-  rb_define_method(klass, "optional", MessageBuilderContext_optional, -1);
-  rb_define_method(klass, "proto3_optional", MessageBuilderContext_proto3_optional, -1);
-  rb_define_method(klass, "required", MessageBuilderContext_required, -1);
-  rb_define_method(klass, "repeated", MessageBuilderContext_repeated, -1);
-  rb_define_method(klass, "map", MessageBuilderContext_map, -1);
-  rb_define_method(klass, "oneof", MessageBuilderContext_oneof, 1);
-  rb_gc_register_address(&cMessageBuilderContext);
-  cMessageBuilderContext = klass;
+static VALUE MessageBuilderContext_alloc(VALUE klass) {
+  MessageBuilderContext* self = ALLOC(MessageBuilderContext);
+  VALUE ret = TypedData_Wrap_Struct(klass, &MessageBuilderContext_type, self);
+  self->file_builder = Qnil;
+  return ret;
 }
 
 /*
@@ -1451,10 +1685,9 @@ void MessageBuilderContext_register(VALUE module) {
  * builder context. This class is intended to serve as a DSL context to be used
  * with #instance_eval.
  */
-VALUE MessageBuilderContext_initialize(VALUE _self,
-                                       VALUE _file_builder,
-                                       VALUE name) {
-  DEFINE_SELF(MessageBuilderContext, self, _self);
+static VALUE MessageBuilderContext_initialize(VALUE _self, VALUE _file_builder,
+                                              VALUE name) {
+  MessageBuilderContext* self = ruby_to_MessageBuilderContext(_self);
   FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
   google_protobuf_FileDescriptorProto* file_proto = file_builder->file_proto;
 
@@ -1472,7 +1705,7 @@ 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,
                              bool proto3_optional) {
-  DEFINE_SELF(MessageBuilderContext, self, msgbuilder_rb);
+  MessageBuilderContext* self = ruby_to_MessageBuilderContext(msgbuilder_rb);
   FileBuilderContext* file_context =
       ruby_to_FileBuilderContext(self->file_builder);
   google_protobuf_FieldDescriptorProto* field_proto;
@@ -1527,9 +1760,16 @@ static void msgdef_add_field(VALUE msgbuilder_rb, upb_label_t label, VALUE name,
   }
 }
 
+#if RUBY_API_VERSION_CODE >= 20700
+static VALUE make_mapentry(VALUE _message_builder, VALUE types, int argc,
+                           const VALUE* argv, VALUE blockarg) {
+  (void)blockarg;
+#else
 static VALUE make_mapentry(VALUE _message_builder, VALUE types, int argc,
                            VALUE* argv) {
-  DEFINE_SELF(MessageBuilderContext, message_builder, _message_builder);
+#endif
+  MessageBuilderContext* message_builder =
+      ruby_to_MessageBuilderContext(_message_builder);
   VALUE type_class = rb_ary_entry(types, 2);
   FileBuilderContext* file_context =
       ruby_to_FileBuilderContext(message_builder->file_builder);
@@ -1596,8 +1836,8 @@ VALUE MessageBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
  * FieldDescriptor#type=) and the type_class must be a string, if present (as
  * accepted by FieldDescriptor#submsg_name=).
  */
-VALUE MessageBuilderContext_proto3_optional(int argc, VALUE* argv,
-                                            VALUE _self) {
+static VALUE MessageBuilderContext_proto3_optional(int argc, VALUE* argv,
+                                                   VALUE _self) {
   VALUE name, type, number;
   VALUE type_class, options = Qnil;
 
@@ -1630,7 +1870,8 @@ VALUE MessageBuilderContext_proto3_optional(int argc, VALUE* argv,
  * completeness. Any attempt to add a message type with required fields to a
  * pool will currently result in an error.
  */
-VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self) {
+static VALUE MessageBuilderContext_required(int argc, VALUE* argv,
+                                            VALUE _self) {
   VALUE name, type, number;
   VALUE type_class, options = Qnil;
 
@@ -1658,7 +1899,8 @@ VALUE MessageBuilderContext_required(int argc, VALUE* argv, VALUE _self) {
  * symbol (as accepted by FieldDescriptor#type=) and the type_class must be a
  * string, if present (as accepted by FieldDescriptor#submsg_name=).
  */
-VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self) {
+static VALUE MessageBuilderContext_repeated(int argc, VALUE* argv,
+                                            VALUE _self) {
   VALUE name, type, number, type_class;
 
   if (argc < 3) {
@@ -1687,8 +1929,8 @@ VALUE MessageBuilderContext_repeated(int argc, VALUE* argv, VALUE _self) {
  * type_class must be a string, if present (as accepted by
  * FieldDescriptor#submsg_name=).
  */
-VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
-  DEFINE_SELF(MessageBuilderContext, self, _self);
+static VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
+  MessageBuilderContext* self = ruby_to_MessageBuilderContext(_self);
   VALUE name, key_type, value_type, number, type_class;
   VALUE mapentry_desc_name;
   FileBuilderContext* file_builder;
@@ -1717,14 +1959,6 @@ VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
 
   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.");
-  }
-
   // Create a new message descriptor for the map entry message, and create a
   // repeated submessage field here with that type.
   msg_name = google_protobuf_DescriptorProto_name(self->msg_proto);
@@ -1768,8 +2002,8 @@ VALUE MessageBuilderContext_map(int argc, VALUE* argv, VALUE _self) {
  *
  * This is the recommended, idiomatic way to build oneof definitions.
  */
-VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name) {
-  DEFINE_SELF(MessageBuilderContext, self, _self);
+static VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name) {
+  MessageBuilderContext* self = ruby_to_MessageBuilderContext(_self);
   size_t oneof_count;
   FileBuilderContext* file_context =
       ruby_to_FileBuilderContext(self->file_builder);
@@ -1795,8 +2029,8 @@ VALUE MessageBuilderContext_oneof(VALUE _self, VALUE name) {
   return Qnil;
 }
 
-void MessageBuilderContext_add_synthetic_oneofs(VALUE _self) {
-  DEFINE_SELF(MessageBuilderContext, self, _self);
+static void MessageBuilderContext_add_synthetic_oneofs(VALUE _self) {
+  MessageBuilderContext* self = ruby_to_MessageBuilderContext(_self);
   FileBuilderContext* file_context =
       ruby_to_FileBuilderContext(self->file_builder);
   size_t field_count, oneof_count;
@@ -1845,42 +2079,59 @@ void MessageBuilderContext_add_synthetic_oneofs(VALUE _self) {
   }
 }
 
+static void MessageBuilderContext_register(VALUE module) {
+  VALUE klass = rb_define_class_under(
+      module, "MessageBuilderContext", rb_cObject);
+  rb_define_alloc_func(klass, MessageBuilderContext_alloc);
+  rb_define_method(klass, "initialize",
+                   MessageBuilderContext_initialize, 2);
+  rb_define_method(klass, "optional", MessageBuilderContext_optional, -1);
+  rb_define_method(klass, "proto3_optional", MessageBuilderContext_proto3_optional, -1);
+  rb_define_method(klass, "required", MessageBuilderContext_required, -1);
+  rb_define_method(klass, "repeated", MessageBuilderContext_repeated, -1);
+  rb_define_method(klass, "map", MessageBuilderContext_map, -1);
+  rb_define_method(klass, "oneof", MessageBuilderContext_oneof, 1);
+  rb_gc_register_address(&cMessageBuilderContext);
+  cMessageBuilderContext = klass;
+}
+
 // -----------------------------------------------------------------------------
 // OneofBuilderContext.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(OneofBuilderContext,
-    "Google::Protobuf::Internal::OneofBuilderContext");
+typedef struct {
+  int oneof_index;
+  VALUE message_builder;
+} OneofBuilderContext;
+
+static VALUE cOneofBuilderContext = Qnil;
 
 void OneofBuilderContext_mark(void* _self) {
   OneofBuilderContext* self = _self;
   rb_gc_mark(self->message_builder);
 }
 
-void OneofBuilderContext_free(void* _self) {
-  xfree(_self);
+static const rb_data_type_t OneofBuilderContext_type = {
+  "Google::Protobuf::Internal::OneofBuilderContext",
+  {OneofBuilderContext_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static OneofBuilderContext* ruby_to_OneofBuilderContext(VALUE val) {
+  OneofBuilderContext* ret;
+  TypedData_Get_Struct(val, OneofBuilderContext, &OneofBuilderContext_type,
+                       ret);
+  return ret;
 }
 
-VALUE OneofBuilderContext_alloc(VALUE klass) {
+static VALUE OneofBuilderContext_alloc(VALUE klass) {
   OneofBuilderContext* self = ALLOC(OneofBuilderContext);
-  VALUE ret = TypedData_Wrap_Struct(
-      klass, &_OneofBuilderContext_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &OneofBuilderContext_type, self);
   self->oneof_index = 0;
   self->message_builder = Qnil;
   return ret;
 }
 
-void OneofBuilderContext_register(VALUE module) {
-  VALUE klass = rb_define_class_under(
-      module, "OneofBuilderContext", rb_cObject);
-  rb_define_alloc_func(klass, OneofBuilderContext_alloc);
-  rb_define_method(klass, "initialize",
-                   OneofBuilderContext_initialize, 2);
-  rb_define_method(klass, "optional", OneofBuilderContext_optional, -1);
-  rb_gc_register_address(&cOneofBuilderContext);
-  cOneofBuilderContext = klass;
-}
-
 /*
  * call-seq:
  *     OneofBuilderContext.new(oneof_index, message_builder) => context
@@ -1889,10 +2140,9 @@ void OneofBuilderContext_register(VALUE module) {
  * builder context. This class is intended to serve as a DSL context to be used
  * with #instance_eval.
  */
-VALUE OneofBuilderContext_initialize(VALUE _self,
-                                     VALUE oneof_index,
-                                     VALUE message_builder) {
-  DEFINE_SELF(OneofBuilderContext, self, _self);
+static VALUE OneofBuilderContext_initialize(VALUE _self, VALUE oneof_index,
+                                            VALUE message_builder) {
+  OneofBuilderContext* self = ruby_to_OneofBuilderContext(_self);
   self->oneof_index = NUM2INT(oneof_index);
   self->message_builder = message_builder;
   return Qnil;
@@ -1908,8 +2158,8 @@ VALUE OneofBuilderContext_initialize(VALUE _self,
  * (as accepted by FieldDescriptor#type=) and the type_class must be a string,
  * if present (as accepted by FieldDescriptor#submsg_name=).
  */
-VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
-  DEFINE_SELF(OneofBuilderContext, self, _self);
+static VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
+  OneofBuilderContext* self = ruby_to_OneofBuilderContext(_self);
   VALUE name, type, number;
   VALUE type_class, options = Qnil;
 
@@ -1921,41 +2171,53 @@ VALUE OneofBuilderContext_optional(int argc, VALUE* argv, VALUE _self) {
   return Qnil;
 }
 
+static void OneofBuilderContext_register(VALUE module) {
+  VALUE klass = rb_define_class_under(
+      module, "OneofBuilderContext", rb_cObject);
+  rb_define_alloc_func(klass, OneofBuilderContext_alloc);
+  rb_define_method(klass, "initialize",
+                   OneofBuilderContext_initialize, 2);
+  rb_define_method(klass, "optional", OneofBuilderContext_optional, -1);
+  rb_gc_register_address(&cOneofBuilderContext);
+  cOneofBuilderContext = klass;
+}
+
 // -----------------------------------------------------------------------------
 // EnumBuilderContext.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(EnumBuilderContext,
-    "Google::Protobuf::Internal::EnumBuilderContext");
+typedef struct {
+  google_protobuf_EnumDescriptorProto* enum_proto;
+  VALUE file_builder;
+} EnumBuilderContext;
+
+static VALUE cEnumBuilderContext = Qnil;
 
 void EnumBuilderContext_mark(void* _self) {
   EnumBuilderContext* self = _self;
   rb_gc_mark(self->file_builder);
 }
 
-void EnumBuilderContext_free(void* _self) {
-  xfree(_self);
+static const rb_data_type_t EnumBuilderContext_type = {
+  "Google::Protobuf::Internal::EnumBuilderContext",
+  {EnumBuilderContext_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static EnumBuilderContext* ruby_to_EnumBuilderContext(VALUE val) {
+  EnumBuilderContext* ret;
+  TypedData_Get_Struct(val, EnumBuilderContext, &EnumBuilderContext_type, ret);
+  return ret;
 }
 
-VALUE EnumBuilderContext_alloc(VALUE klass) {
+static VALUE EnumBuilderContext_alloc(VALUE klass) {
   EnumBuilderContext* self = ALLOC(EnumBuilderContext);
-  VALUE ret = TypedData_Wrap_Struct(
-      klass, &_EnumBuilderContext_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &EnumBuilderContext_type, self);
   self->enum_proto = NULL;
   self->file_builder = Qnil;
   return ret;
 }
 
-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, 2);
-  rb_define_method(klass, "value", EnumBuilderContext_value, 2);
-  rb_gc_register_address(&cEnumBuilderContext);
-  cEnumBuilderContext = klass;
-}
-
 /*
  * call-seq:
  *     EnumBuilderContext.new(file_builder) => context
@@ -1963,9 +2225,9 @@ void EnumBuilderContext_register(VALUE module) {
  * 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 _file_builder,
-                                    VALUE name) {
-  DEFINE_SELF(EnumBuilderContext, self, _self);
+static VALUE EnumBuilderContext_initialize(VALUE _self, VALUE _file_builder,
+                                           VALUE name) {
+  EnumBuilderContext* self = ruby_to_EnumBuilderContext(_self);
   FileBuilderContext* file_builder = ruby_to_FileBuilderContext(_file_builder);
   google_protobuf_FileDescriptorProto* file_proto = file_builder->file_proto;
 
@@ -1986,8 +2248,8 @@ VALUE EnumBuilderContext_initialize(VALUE _self, VALUE _file_builder,
  * Adds the given name => number mapping to the enum type. Name must be a Ruby
  * symbol.
  */
-VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number) {
-  DEFINE_SELF(EnumBuilderContext, self, _self);
+static VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number) {
+  EnumBuilderContext* self = ruby_to_EnumBuilderContext(_self);
   FileBuilderContext* file_builder =
       ruby_to_FileBuilderContext(self->file_builder);
   google_protobuf_EnumValueDescriptorProto* enum_value;
@@ -2003,196 +2265,53 @@ VALUE EnumBuilderContext_value(VALUE _self, VALUE name, VALUE number) {
   return Qnil;
 }
 
-
-// -----------------------------------------------------------------------------
-// FileBuilderContext.
-// -----------------------------------------------------------------------------
-
-DEFINE_CLASS(FileBuilderContext,
-             "Google::Protobuf::Internal::FileBuilderContext");
-
-void FileBuilderContext_mark(void* _self) {
-  FileBuilderContext* self = _self;
-  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->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, 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);
-  cFileBuilderContext = klass;
-}
-
-/*
- * call-seq:
- *     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 descriptor_pool,
-                                    VALUE name, VALUE options) {
-  DEFINE_SELF(FileBuilderContext, self, _self);
-  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;
-}
-
-/*
- * call-seq:
- *     FileBuilderContext.add_message(name, &block)
- *
- * Creates a new, empty descriptor with the given name, and invokes the block in
- * the context of a MessageBuilderContext on that descriptor. The block can then
- * call, e.g., MessageBuilderContext#optional and MessageBuilderContext#repeated
- * methods to define the message fields.
- *
- * This is the recommended, idiomatic way to build message definitions.
- */
-VALUE FileBuilderContext_add_message(VALUE _self, VALUE name) {
-  VALUE args[2] = { _self, name };
-  VALUE ctx = rb_class_new_instance(2, args, cMessageBuilderContext);
-  VALUE block = rb_block_proc();
-  rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  MessageBuilderContext_add_synthetic_oneofs(ctx);
-  return Qnil;
-}
-
-/*
- * call-seq:
- *     FileBuilderContext.add_enum(name, &block)
- *
- * Creates a new, empty enum descriptor with the given name, and invokes the
- * block in the context of an EnumBuilderContext on that descriptor. The block
- * can then call EnumBuilderContext#add_value to define the enum values.
- *
- * This is the recommended, idiomatic way to build enum definitions.
- */
-VALUE FileBuilderContext_add_enum(VALUE _self, VALUE name) {
-  VALUE args[2] = { _self, name };
-  VALUE ctx = rb_class_new_instance(2, args, cEnumBuilderContext);
-  VALUE block = rb_block_proc();
-  rb_funcall_with_block(ctx, rb_intern("instance_eval"), 0, NULL, block);
-  return Qnil;
-}
-
-void FileBuilderContext_build(VALUE _self) {
-  DEFINE_SELF(FileBuilderContext, self, _self);
-  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));
-  }
+static 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, 2);
+  rb_define_method(klass, "value", EnumBuilderContext_value, 2);
+  rb_gc_register_address(&cEnumBuilderContext);
+  cEnumBuilderContext = klass;
 }
 
 // -----------------------------------------------------------------------------
 // Builder.
 // -----------------------------------------------------------------------------
 
-DEFINE_CLASS(Builder, "Google::Protobuf::Internal::Builder");
+typedef struct {
+  VALUE descriptor_pool;
+  VALUE default_file_builder;
+} Builder;
 
-void Builder_mark(void* _self) {
+static VALUE cBuilder = Qnil;
+
+static void Builder_mark(void* _self) {
   Builder* self = _self;
   rb_gc_mark(self->descriptor_pool);
   rb_gc_mark(self->default_file_builder);
 }
 
-void Builder_free(void* _self) {
-  xfree(_self);
+static const rb_data_type_t Builder_type = {
+  "Google::Protobuf::Internal::Builder",
+  {Builder_mark, RUBY_DEFAULT_FREE, NULL},
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static Builder* ruby_to_Builder(VALUE val) {
+  Builder* ret;
+  TypedData_Get_Struct(val, Builder, &Builder_type, ret);
+  return ret;
 }
 
-VALUE Builder_alloc(VALUE klass) {
+static VALUE Builder_alloc(VALUE klass) {
   Builder* self = ALLOC(Builder);
-  VALUE ret = TypedData_Wrap_Struct(
-      klass, &_Builder_type, self);
+  VALUE ret = TypedData_Wrap_Struct(klass, &Builder_type, self);
   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, 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_gc_register_address(&cBuilder);
-  cBuilder = klass;
-}
-
 /*
  * call-seq:
  *     Builder.new(descriptor_pool) => builder
@@ -2201,8 +2320,8 @@ void Builder_register(VALUE module) {
  * descriptors and atomically register them into a pool in a way that allows for
  * (co)recursive type references.
  */
-VALUE Builder_initialize(VALUE _self, VALUE pool) {
-  DEFINE_SELF(Builder, self, _self);
+static VALUE Builder_initialize(VALUE _self, VALUE pool) {
+  Builder* self = ruby_to_Builder(_self);
   self->descriptor_pool = pool;
   self->default_file_builder = Qnil;  // Created lazily if needed.
   return Qnil;
@@ -2219,8 +2338,8 @@ VALUE Builder_initialize(VALUE _self, VALUE pool) {
  *
  * This is the recommended, idiomatic way to build file descriptors.
  */
-VALUE Builder_add_file(int argc, VALUE* argv, VALUE _self) {
-  DEFINE_SELF(Builder, self, _self);
+static VALUE Builder_add_file(int argc, VALUE* argv, VALUE _self) {
+  Builder* self = ruby_to_Builder(_self);
   VALUE name, options;
   VALUE ctx;
   VALUE block;
@@ -2240,7 +2359,7 @@ VALUE Builder_add_file(int argc, VALUE* argv, VALUE _self) {
 }
 
 static VALUE Builder_get_default_file(VALUE _self) {
-  DEFINE_SELF(Builder, self, _self);
+  Builder* self = ruby_to_Builder(_self);
 
   /* Lazily create only if legacy builder-level methods are called. */
   if (self->default_file_builder == Qnil) {
@@ -2264,7 +2383,7 @@ static VALUE Builder_get_default_file(VALUE _self) {
  * files generated by protoc which don't add messages within "add_file" block.
  * Descriptors created this way get assigned to a default empty FileDescriptor.
  */
-VALUE Builder_add_message(VALUE _self, VALUE name) {
+static VALUE Builder_add_message(VALUE _self, VALUE name) {
   VALUE file_builder = Builder_get_default_file(_self);
   rb_funcall_with_block(file_builder, rb_intern("add_message"), 1, &name,
                         rb_block_proc());
@@ -2283,7 +2402,7 @@ VALUE Builder_add_message(VALUE _self, VALUE name) {
  * Enum descriptors created this way get assigned to a default empty
  * FileDescriptor.
  */
-VALUE Builder_add_enum(VALUE _self, VALUE name) {
+static VALUE Builder_add_enum(VALUE _self, VALUE name) {
   VALUE file_builder = Builder_get_default_file(_self);
   rb_funcall_with_block(file_builder, rb_intern("add_enum"), 1, &name,
                         rb_block_proc());
@@ -2292,8 +2411,8 @@ VALUE Builder_add_enum(VALUE _self, VALUE name) {
 
 /* This method is hidden from Ruby, and only called directly from
  * DescriptorPool_build(). */
-VALUE Builder_build(VALUE _self) {
-  DEFINE_SELF(Builder, self, _self);
+static VALUE Builder_build(VALUE _self) {
+  Builder* self = ruby_to_Builder(_self);
 
   if (self->default_file_builder != Qnil) {
     FileBuilderContext_build(self->default_file_builder);
@@ -2303,8 +2422,19 @@ VALUE Builder_build(VALUE _self) {
   return Qnil;
 }
 
+static 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, 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_gc_register_address(&cBuilder);
+  cBuilder = klass;
+}
+
 static VALUE get_def_obj(VALUE _descriptor_pool, const void* ptr, VALUE klass) {
-  DEFINE_SELF(DescriptorPool, descriptor_pool, _descriptor_pool);
+  DescriptorPool* descriptor_pool = ruby_to_DescriptorPool(_descriptor_pool);
   VALUE key = ULL2NUM((intptr_t)ptr);
   VALUE def;
 
@@ -2319,48 +2449,111 @@ static VALUE get_def_obj(VALUE _descriptor_pool, const void* ptr, VALUE klass) {
     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));
-        }
-      }
-    }
   }
 
   return def;
 }
 
-VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_msgdef* def) {
+static VALUE get_msgdef_obj(VALUE descriptor_pool, const upb_msgdef* def) {
   return get_def_obj(descriptor_pool, def, cDescriptor);
 }
 
-VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_enumdef* def) {
+static 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) {
+static 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) {
+static 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) {
+static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_oneofdef* def) {
   return get_def_obj(descriptor_pool, def, cOneofDescriptor);
 }
+
+// -----------------------------------------------------------------------------
+// Shared functions
+// -----------------------------------------------------------------------------
+
+// Functions exposed to other modules in defs.h.
+
+VALUE Descriptor_DefToClass(const upb_msgdef *m) {
+  const upb_symtab *symtab = upb_filedef_symtab(upb_msgdef_file(m));
+  VALUE pool = ObjectCache_Get(symtab);
+  PBRUBY_ASSERT(pool != Qnil);
+  VALUE desc_rb = get_msgdef_obj(pool, m);
+  const Descriptor* desc = ruby_to_Descriptor(desc_rb);
+  return desc->klass;
+}
+
+const upb_msgdef *Descriptor_GetMsgDef(VALUE desc_rb) {
+  const Descriptor* desc = ruby_to_Descriptor(desc_rb);
+  return desc->msgdef;
+}
+
+VALUE TypeInfo_InitArg(int argc, VALUE *argv, int skip_arg) {
+  if (argc > skip_arg) {
+    if (argc > 1 + skip_arg) {
+      rb_raise(rb_eArgError, "Expected a maximum of %d arguments.", skip_arg + 1);
+    }
+    return argv[skip_arg];
+  } else {
+    return Qnil;
+  }
+}
+
+TypeInfo TypeInfo_FromClass(int argc, VALUE* argv, int skip_arg,
+                            VALUE* type_class, VALUE* init_arg) {
+  TypeInfo ret = {ruby_to_fieldtype(argv[skip_arg])};
+
+  if (ret.type == UPB_TYPE_MESSAGE || ret.type == UPB_TYPE_ENUM) {
+    *init_arg = TypeInfo_InitArg(argc, argv, skip_arg + 2);
+
+    if (argc < 2 + skip_arg) {
+      rb_raise(rb_eArgError, "Expected at least %d arguments for message/enum.",
+               2 + skip_arg);
+    }
+
+    VALUE klass = argv[1 + skip_arg];
+    VALUE desc = MessageOrEnum_GetDescriptor(klass);
+    *type_class = klass;
+
+    if (desc == Qnil) {
+      rb_raise(rb_eArgError,
+               "Type class has no descriptor. Please pass a "
+               "class or enum as returned by the DescriptorPool.");
+    }
+
+    if (ret.type == UPB_TYPE_MESSAGE) {
+      ret.def.msgdef = ruby_to_Descriptor(desc)->msgdef;
+      Message_CheckClass(klass);
+    } else {
+      PBRUBY_ASSERT(ret.type == UPB_TYPE_ENUM);
+      ret.def.enumdef = ruby_to_EnumDescriptor(desc)->enumdef;
+    }
+  } else {
+    *init_arg = TypeInfo_InitArg(argc, argv, skip_arg + 1);
+  }
+
+  return ret;
+}
+
+void Defs_register(VALUE module) {
+  DescriptorPool_register(module);
+  Descriptor_register(module);
+  FileDescriptor_register(module);
+  FieldDescriptor_register(module);
+  OneofDescriptor_register(module);
+  EnumDescriptor_register(module);
+  FileBuilderContext_register(module);
+  MessageBuilderContext_register(module);
+  OneofBuilderContext_register(module);
+  EnumBuilderContext_register(module);
+  Builder_register(module);
+
+  rb_gc_register_address(&c_only_cookie);
+  c_only_cookie = rb_class_new_instance(0, NULL, rb_cObject);
+}