diff --git a/python/message.c b/python/message.c
index 08cba55..7ef2f92 100644
--- a/python/message.c
+++ b/python/message.c
@@ -37,7 +37,7 @@
 #include "upb/text_encode.h"
 #include "upb/util/required_fields.h"
 
-static const upb_msgdef* PyUpb_MessageMeta_GetMsgdef(PyObject* cls);
+static const upb_MessageDef* PyUpb_MessageMeta_GetMsgdef(PyObject* cls);
 static PyObject* PyUpb_MessageMeta_GetAttr(PyObject* self, PyObject* name);
 
 // -----------------------------------------------------------------------------
@@ -63,7 +63,7 @@
   // the version of Python we were compiled against, which may be different
   // than the version we are dynamically linked against.  Here we want the
   // version that is actually running in this process.
-  long python_version_hex;     // PY_VERSION_HEX
+  long python_version_hex;  // PY_VERSION_HEX
 } PyUpb_CPythonBits;
 
 // A global containing the values for this process.
@@ -151,9 +151,9 @@
 // The parent may also be non-present, in which case a mutation will trigger a
 // chain reaction.
 typedef struct PyUpb_CMessage {
-  PyObject_HEAD
+  PyObject_HEAD;
   PyObject* arena;
-  uintptr_t def;  // Tagged, low bit 1 == upb_fielddef*, else upb_msgdef*
+  uintptr_t def;  // Tagged, low bit 1 == upb_FieldDef*, else upb_MessageDef*
   union {
     // when def is msgdef, the data for this msg.
     upb_msg* msg;
@@ -170,18 +170,18 @@
 
 bool PyUpb_CMessage_IsStub(PyUpb_CMessage* msg) { return msg->def & 1; }
 
-const upb_fielddef* PyUpb_CMessage_GetFieldDef(PyUpb_CMessage* msg) {
+const upb_FieldDef* PyUpb_CMessage_GetFieldDef(PyUpb_CMessage* msg) {
   assert(PyUpb_CMessage_IsStub(msg));
   return (void*)(msg->def & ~(uintptr_t)1);
 }
 
-static const upb_msgdef* _PyUpb_CMessage_GetMsgdef(PyUpb_CMessage* msg) {
+static const upb_MessageDef* _PyUpb_CMessage_GetMsgdef(PyUpb_CMessage* msg) {
   return PyUpb_CMessage_IsStub(msg)
-             ? upb_fielddef_msgsubdef(PyUpb_CMessage_GetFieldDef(msg))
+             ? upb_FieldDef_MessageSubDef(PyUpb_CMessage_GetFieldDef(msg))
              : (void*)msg->def;
 }
 
-const upb_msgdef* PyUpb_CMessage_GetMsgdef(PyObject* self) {
+const upb_MessageDef* PyUpb_CMessage_GetMsgdef(PyObject* self) {
   return _PyUpb_CMessage_GetMsgdef((PyUpb_CMessage*)self);
 }
 
@@ -214,11 +214,11 @@
 
 static PyObject* PyUpb_CMessage_New(PyObject* cls, PyObject* unused_args,
                                     PyObject* unused_kwargs) {
-  const upb_msgdef* msgdef = PyUpb_MessageMeta_GetMsgdef(cls);
+  const upb_MessageDef* msgdef = PyUpb_MessageMeta_GetMsgdef(cls);
   PyUpb_CMessage* msg = (void*)PyType_GenericAlloc((PyTypeObject*)cls, 0);
   msg->def = (uintptr_t)msgdef;
   msg->arena = PyUpb_Arena_New();
-  msg->ptr.msg = upb_msg_new(msgdef, PyUpb_Arena_Get(msg->arena));
+  msg->ptr.msg = upb_Message_New(msgdef, PyUpb_Arena_Get(msg->arena));
   msg->unset_subobj_map = NULL;
   msg->ext_dict = NULL;
   msg->version = 0;
@@ -238,8 +238,8 @@
  * and sets an exception of type `exc_type` if provided.
  */
 static bool PyUpb_CMessage_LookupName(PyUpb_CMessage* self, PyObject* py_name,
-                                      const upb_fielddef** f,
-                                      const upb_oneofdef** o,
+                                      const upb_FieldDef** f,
+                                      const upb_OneofDef** o,
                                       PyObject* exc_type) {
   assert(f || o);
   Py_ssize_t size;
@@ -250,13 +250,12 @@
     PyBytes_AsStringAndSize(py_name, (char**)&name, &size);
   }
   if (!name) return NULL;
-  const upb_msgdef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
+  const upb_MessageDef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
 
-  if (!upb_msgdef_lookupname(msgdef, name, size, f, o)) {
+  if (!upb_MessageDef_FindByNameWithSize(msgdef, name, size, f, o)) {
     if (exc_type) {
-      PyErr_Format(exc_type,
-                   "Protocol message %s has no \"%s\" field.",
-                   upb_msgdef_name(msgdef), name);
+      PyErr_Format(exc_type, "Protocol message %s has no \"%s\" field.",
+                   upb_MessageDef_Name(msgdef), name);
     }
     return false;
   }
@@ -296,17 +295,17 @@
 }
 
 int PyUpb_CMessage_InitMapAttributes(PyObject* map, PyObject* value,
-                                     const upb_fielddef* f) {
-  const upb_msgdef* entry_m = upb_fielddef_msgsubdef(f);
-  const upb_fielddef* val_f = upb_msgdef_field(entry_m, 1);
+                                     const upb_FieldDef* f) {
+  const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(f);
+  const upb_FieldDef* val_f = upb_MessageDef_Field(entry_m, 1);
   PyObject* it = NULL;
   PyObject* tmp = NULL;
   int ret = -1;
-  if (upb_fielddef_issubmsg(val_f)) {
+  if (upb_FieldDef_IsSubMessage(val_f)) {
     it = PyObject_GetIter(value);
     if (it == NULL) {
       PyErr_Format(PyExc_TypeError, "Argument for field %s is not iterable",
-                   upb_fielddef_fullname(f));
+                   upb_FieldDef_FullName(f));
       goto err;
     }
     PyObject* e;
@@ -334,7 +333,7 @@
 void PyUpb_CMessage_EnsureReified(PyUpb_CMessage* self);
 
 static bool PyUpb_CMessage_InitMapAttribute(PyObject* _self, PyObject* name,
-                                            const upb_fielddef* f,
+                                            const upb_FieldDef* f,
                                             PyObject* value) {
   PyObject* map = PyUpb_CMessage_GetAttr(_self, name);
   int ok = PyUpb_CMessage_InitMapAttributes(map, value, f);
@@ -366,9 +365,9 @@
     assert(!PyErr_Occurred());
     ok = PyUpb_CMessage_InitAttributes(submsg, NULL, value) >= 0;
   } else {
-    const upb_msgdef* m = PyUpb_CMessage_GetMsgdef(_self);
+    const upb_MessageDef* m = PyUpb_CMessage_GetMsgdef(_self);
     PyErr_Format(PyExc_TypeError, "Message must be initialized with a dict: %s",
-                 upb_msgdef_fullname(m));
+                 upb_MessageDef_FullName(m));
     ok = false;
   }
   Py_DECREF(submsg);
@@ -376,13 +375,13 @@
 }
 
 static bool PyUpb_CMessage_InitScalarAttribute(upb_msg* msg,
-                                               const upb_fielddef* f,
+                                               const upb_FieldDef* f,
                                                PyObject* value,
-                                               upb_arena* arena) {
-  upb_msgval msgval;
+                                               upb_Arena* arena) {
+  upb_MessageValue msgval;
   assert(!PyErr_Occurred());
   if (!PyUpb_PyToUpb(value, f, &msgval, arena)) return false;
-  upb_msg_set(msg, f, msgval, arena);
+  upb_Message_Set(msg, f, msgval, arena);
   return true;
 }
 
@@ -403,11 +402,11 @@
   PyObject* value;
   PyUpb_CMessage_EnsureReified(self);
   upb_msg* msg = PyUpb_CMessage_GetMsg(self);
-  upb_arena* arena = PyUpb_Arena_Get(self->arena);
+  upb_Arena* arena = PyUpb_Arena_Get(self->arena);
 
   while (PyDict_Next(kwargs, &pos, &name, &value)) {
     assert(!PyErr_Occurred());
-    const upb_fielddef* f;
+    const upb_FieldDef* f;
     assert(!PyErr_Occurred());
     if (!PyUpb_CMessage_LookupName(self, name, &f, NULL, PyExc_ValueError)) {
       return -1;
@@ -417,11 +416,11 @@
 
     assert(!PyErr_Occurred());
 
-    if (upb_fielddef_ismap(f)) {
+    if (upb_FieldDef_IsMap(f)) {
       if (!PyUpb_CMessage_InitMapAttribute(_self, name, f, value)) return -1;
-    } else if (upb_fielddef_isseq(f)) {
+    } else if (upb_FieldDef_IsRepeated(f)) {
       if (!PyUpb_CMessage_InitRepeatedAttribute(_self, name, value)) return -1;
-    } else if (upb_fielddef_issubmsg(f)) {
+    } else if (upb_FieldDef_IsSubMessage(f)) {
       if (!PyUpb_CMessage_InitMessageAttribute(_self, name, value)) return -1;
     } else {
       if (!PyUpb_CMessage_InitScalarAttribute(msg, f, value, arena)) return -1;
@@ -443,9 +442,9 @@
   return PyUpb_CMessage_InitAttributes(_self, args, kwargs);
 }
 
-static PyObject* PyUpb_CMessage_NewStub(PyObject* parent, const upb_fielddef* f,
+static PyObject* PyUpb_CMessage_NewStub(PyObject* parent, const upb_FieldDef* f,
                                         PyObject* arena) {
-  const upb_msgdef* sub_m = upb_fielddef_msgsubdef(f);
+  const upb_MessageDef* sub_m = upb_FieldDef_MessageSubDef(f);
   PyObject* cls = PyUpb_Descriptor_GetClass(sub_m);
 
   PyUpb_CMessage* msg = (void*)PyType_GenericAlloc((PyTypeObject*)cls, 0);
@@ -468,9 +467,9 @@
   if (!PyObject_TypeCheck(_m2, m1->ob_base.ob_type)) {
     return false;
   }
-  const upb_msgdef* m1_msgdef = _PyUpb_CMessage_GetMsgdef(m1);
+  const upb_MessageDef* m1_msgdef = _PyUpb_CMessage_GetMsgdef(m1);
 #ifndef NDEBUG
-  const upb_msgdef* m2_msgdef = _PyUpb_CMessage_GetMsgdef(m2);
+  const upb_MessageDef* m2_msgdef = _PyUpb_CMessage_GetMsgdef(m2);
   assert(m1_msgdef == m2_msgdef);
 #endif
   const upb_msg* m1_msg = PyUpb_CMessage_GetIfReified((PyObject*)m1);
@@ -478,20 +477,20 @@
   return PyUpb_Message_IsEqual(m1_msg, m2_msg, m1_msgdef);
 }
 
-static const upb_fielddef* PyUpb_CMessage_InitAsMsg(PyUpb_CMessage* m,
-                                                    upb_arena* arena) {
-  const upb_fielddef* f = PyUpb_CMessage_GetFieldDef(m);
-  m->ptr.msg = upb_msg_new(upb_fielddef_msgsubdef(f), arena);
-  m->def = (uintptr_t)upb_fielddef_msgsubdef(f);
+static const upb_FieldDef* PyUpb_CMessage_InitAsMsg(PyUpb_CMessage* m,
+                                                    upb_Arena* arena) {
+  const upb_FieldDef* f = PyUpb_CMessage_GetFieldDef(m);
+  m->ptr.msg = upb_Message_New(upb_FieldDef_MessageSubDef(f), arena);
+  m->def = (uintptr_t)upb_FieldDef_MessageSubDef(f);
   PyUpb_ObjCache_Add(m->ptr.msg, &m->ob_base);
   return f;
 }
 
 static void PyUpb_CMessage_SetField(PyUpb_CMessage* parent,
-                                    const upb_fielddef* f,
-                                    PyUpb_CMessage* child, upb_arena* arena) {
-  upb_msgval msgval = {.msg_val = PyUpb_CMessage_GetMsg(child)};
-  upb_msg_set(PyUpb_CMessage_GetMsg(parent), f, msgval, arena);
+                                    const upb_FieldDef* f,
+                                    PyUpb_CMessage* child, upb_Arena* arena) {
+  upb_MessageValue msgval = {.msg_val = PyUpb_CMessage_GetMsg(child)};
+  upb_Message_Set(PyUpb_CMessage_GetMsg(parent), f, msgval, arena);
   PyUpb_WeakMap_Delete(parent->unset_subobj_map, f);
   // Releases a ref previously owned by child->ptr.parent of our child.
   Py_DECREF(child);
@@ -517,18 +516,18 @@
  */
 void PyUpb_CMessage_EnsureReified(PyUpb_CMessage* self) {
   if (!PyUpb_CMessage_IsStub(self)) return;
-  upb_arena* arena = PyUpb_Arena_Get(self->arena);
+  upb_Arena* arena = PyUpb_Arena_Get(self->arena);
 
   // This is a non-present message. We need to create a real upb_msg for this
   // object and every parent until we reach a present message.
   PyUpb_CMessage* child = self;
   PyUpb_CMessage* parent = self->ptr.parent;
-  const upb_fielddef* child_f = PyUpb_CMessage_InitAsMsg(child, arena);
+  const upb_FieldDef* child_f = PyUpb_CMessage_InitAsMsg(child, arena);
   Py_INCREF(child);  // To avoid a special-case in PyUpb_CMessage_SetField().
 
   do {
     PyUpb_CMessage* next_parent = parent->ptr.parent;
-    const upb_fielddef* parent_f = NULL;
+    const upb_FieldDef* parent_f = NULL;
     if (PyUpb_CMessage_IsStub(parent)) {
       parent_f = PyUpb_CMessage_InitAsMsg(parent, arena);
     }
@@ -549,20 +548,20 @@
  * PyUpb_CMessage_Reify()
  *
  * The message equivalent of PyUpb_*Container_Reify(), this transitions
- * the wrapper from the unset state (owning a reference on self->ptr.parent) to the
- * set state (having a non-owning pointer to self->ptr.msg).
+ * the wrapper from the unset state (owning a reference on self->ptr.parent) to
+ * the set state (having a non-owning pointer to self->ptr.msg).
  */
-static void PyUpb_CMessage_Reify(PyUpb_CMessage* self, const upb_fielddef* f,
+static void PyUpb_CMessage_Reify(PyUpb_CMessage* self, const upb_FieldDef* f,
                                  upb_msg* msg) {
   assert(f == PyUpb_CMessage_GetFieldDef(self));
   if (!msg) {
-    const upb_msgdef* msgdef = PyUpb_CMessage_GetMsgdef((PyObject*)self);
-    msg = upb_msg_new(msgdef, PyUpb_Arena_Get(self->arena));
+    const upb_MessageDef* msgdef = PyUpb_CMessage_GetMsgdef((PyObject*)self);
+    msg = upb_Message_New(msgdef, PyUpb_Arena_Get(self->arena));
   }
   PyUpb_ObjCache_Add(msg, &self->ob_base);
   Py_DECREF(&self->ptr.parent->ob_base);
   self->ptr.msg = msg;  // Overwrites self->ptr.parent
-  self->def = (uintptr_t)upb_fielddef_msgsubdef(f);
+  self->def = (uintptr_t)upb_FieldDef_MessageSubDef(f);
   PyUpb_CMessage_SyncSubobjs(self);
 }
 
@@ -580,7 +579,7 @@
  *   # SyncSubobjs() is required to connect our existing 'sub' wrapper to the
  *   # newly created foo.submsg data in C.
  *   foo.MergeFrom(FooMessage(submsg={}))
- * 
+ *
  * This requires that all of the new sub-objects that have appeared are owned
  * by `self`'s arena.
  */
@@ -601,16 +600,16 @@
   Py_INCREF(&self->ob_base);
 
   while (PyUpb_WeakMap_Next(subobj_map, &key, &obj, &iter)) {
-    const upb_fielddef* f = key;
-    if (upb_fielddef_haspresence(f) && !upb_msg_has(msg, f)) continue;
-    upb_msgval msgval = upb_msg_get(msg, f);
+    const upb_FieldDef* f = key;
+    if (upb_FieldDef_HasPresence(f) && !upb_Message_Has(msg, f)) continue;
+    upb_MessageValue msgval = upb_Message_Get(msg, f);
     PyUpb_WeakMap_DeleteIter(subobj_map, &iter);
-    if (upb_fielddef_ismap(f)) {
+    if (upb_FieldDef_IsMap(f)) {
       if (!msgval.map_val) continue;
-      PyUpb_MapContainer_Reify(obj, (upb_map*)msgval.map_val);
-    } else if (upb_fielddef_isseq(f)) {
+      PyUpb_MapContainer_Reify(obj, (upb_Map*)msgval.map_val);
+    } else if (upb_FieldDef_IsRepeated(f)) {
       if (!msgval.array_val) continue;
-      PyUpb_RepeatedContainer_Reify(obj, (upb_array*)msgval.array_val);
+      PyUpb_RepeatedContainer_Reify(obj, (upb_Array*)msgval.array_val);
     } else {
       PyUpb_CMessage* sub = (void*)obj;
       assert(self == sub->ptr.parent);
@@ -629,8 +628,8 @@
     return PyUnicode_FromStringAndSize(NULL, 0);
   }
   upb_msg* msg = PyUpb_CMessage_GetMsg(self);
-  const upb_msgdef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
-  const upb_symtab* symtab = upb_filedef_symtab(upb_msgdef_file(msgdef));
+  const upb_MessageDef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
+  const upb_DefPool* symtab = upb_FileDef_Pool(upb_MessageDef_File(msgdef));
   char buf[1024];
   int options = UPB_TXTENC_SKIPUNKNOWN;
   size_t size = upb_text_encode(msg, msgdef, symtab, options, buf, sizeof(buf));
@@ -659,17 +658,17 @@
   return PyBool_FromLong(ret);
 }
 
-void PyUpb_CMessage_CacheDelete(PyObject* _self, const upb_fielddef* f) {
+void PyUpb_CMessage_CacheDelete(PyObject* _self, const upb_FieldDef* f) {
   PyUpb_CMessage* self = (void*)_self;
   PyUpb_WeakMap_Delete(self->unset_subobj_map, f);
 }
 
-void PyUpb_CMessage_SetConcreteSubobj(PyObject* _self, const upb_fielddef* f,
-                                      upb_msgval subobj) {
+void PyUpb_CMessage_SetConcreteSubobj(PyObject* _self, const upb_FieldDef* f,
+                                      upb_MessageValue subobj) {
   PyUpb_CMessage* self = (void*)_self;
   PyUpb_CMessage_EnsureReified(self);
   PyUpb_CMessage_CacheDelete(_self, f);
-  upb_msg_set(self->ptr.msg, f, subobj, PyUpb_Arena_Get(self->arena));
+  upb_Message_Set(self->ptr.msg, f, subobj, PyUpb_Arena_Get(self->arena));
 }
 
 static void PyUpb_CMessage_Dealloc(PyObject* _self) {
@@ -702,7 +701,7 @@
   }
 }
 
-PyObject* PyUpb_CMessage_Get(upb_msg* u_msg, const upb_msgdef* m,
+PyObject* PyUpb_CMessage_Get(upb_msg* u_msg, const upb_MessageDef* m,
                              PyObject* arena) {
   PyObject* ret = PyUpb_ObjCache_Get(u_msg);
   if (ret) return ret;
@@ -728,15 +727,15 @@
  *
  * Non-present messages return "stub" objects that point to their parent, but
  * will materialize into real upb objects if they are mutated.
- * 
+ *
  * Note: we do *not* create stubs for repeated/map fields unless the parent
  * is a stub:
- * 
+ *
  *    msg = TestMessage()
  *    msg.submessage                # (A) Creates a stub
  *    msg.repeated_foo              # (B) Does *not* create a stub
  *    msg.submessage.repeated_bar   # (C) Creates a stub
- *    
+ *
  * In case (B) we have some freedom: we could either create a stub, or create
  * a reified object with underlying data.  It appears that either could work
  * equally well, with no observable change to users.  There isn't a clear
@@ -746,7 +745,7 @@
  * within the realm of possibility.
  */
 PyObject* PyUpb_CMessage_GetStub(PyUpb_CMessage* self,
-                                 const upb_fielddef* field) {
+                                 const upb_FieldDef* field) {
   PyObject* _self = (void*)self;
   if (!self->unset_subobj_map) {
     self->unset_subobj_map = PyUpb_WeakMap_New();
@@ -755,9 +754,9 @@
 
   if (subobj) return subobj;
 
-  if (upb_fielddef_ismap(field)) {
+  if (upb_FieldDef_IsMap(field)) {
     subobj = PyUpb_MapContainer_NewStub(_self, field, self->arena);
-  } else if (upb_fielddef_isseq(field)) {
+  } else if (upb_FieldDef_IsRepeated(field)) {
     subobj = PyUpb_RepeatedContainer_NewStub(_self, field, self->arena);
   } else {
     subobj = PyUpb_CMessage_NewStub(&self->ob_base, field, self->arena);
@@ -769,11 +768,11 @@
 }
 
 PyObject* PyUpb_CMessage_GetPresentWrapper(PyUpb_CMessage* self,
-                                           const upb_fielddef* field) {
+                                           const upb_FieldDef* field) {
   assert(!PyUpb_CMessage_IsStub(self));
-  upb_mutmsgval mutval =
-      upb_msg_mutable(self->ptr.msg, field, PyUpb_Arena_Get(self->arena));
-  if (upb_fielddef_ismap(field)) {
+  upb_MutableMessageValue mutval =
+      upb_Message_Mutable(self->ptr.msg, field, PyUpb_Arena_Get(self->arena));
+  if (upb_FieldDef_IsMap(field)) {
     return PyUpb_MapContainer_GetOrCreateWrapper(mutval.map, field,
                                                  self->arena);
   } else {
@@ -783,13 +782,13 @@
 }
 
 PyObject* PyUpb_CMessage_GetScalarValue(PyUpb_CMessage* self,
-                                        const upb_fielddef* field) {
-  upb_msgval val;
+                                        const upb_FieldDef* field) {
+  upb_MessageValue val;
   if (PyUpb_CMessage_IsStub(self)) {
     // Unset message always returns default values.
-    val = upb_fielddef_default(field);
+    val = upb_FieldDef_Default(field);
   } else {
-    val = upb_msg_get(self->ptr.msg, field);
+    val = upb_Message_Get(self->ptr.msg, field);
   }
   return PyUpb_UpbToPy(val, field, self->arena);
 }
@@ -798,7 +797,7 @@
  * PyUpb_CMessage_GetFieldValue()
  *
  * Implements the equivalent of getattr(msg, field), once `field` has
- * already been resolved to a `upb_fielddef*`.
+ * already been resolved to a `upb_FieldDef*`.
  *
  * This may involve constructing a wrapper object for the given field, or
  * returning one that was previously constructed.  If the field is not actually
@@ -806,14 +805,14 @@
  * connected to any C data.
  */
 PyObject* PyUpb_CMessage_GetFieldValue(PyObject* _self,
-                                       const upb_fielddef* field) {
+                                       const upb_FieldDef* field) {
   PyUpb_CMessage* self = (void*)_self;
-  assert(upb_fielddef_containingtype(field) == PyUpb_CMessage_GetMsgdef(_self));
-  bool submsg = upb_fielddef_issubmsg(field);
-  bool seq = upb_fielddef_isseq(field);
+  assert(upb_FieldDef_ContainingType(field) == PyUpb_CMessage_GetMsgdef(_self));
+  bool submsg = upb_FieldDef_IsSubMessage(field);
+  bool seq = upb_FieldDef_IsRepeated(field);
 
   if ((PyUpb_CMessage_IsStub(self) && (submsg || seq)) ||
-      (submsg && !seq && !upb_msg_has(self->ptr.msg, field))) {
+      (submsg && !seq && !upb_Message_Has(self->ptr.msg, field))) {
     return PyUpb_CMessage_GetStub(self, field);
   } else if (seq) {
     return PyUpb_CMessage_GetPresentWrapper(self, field);
@@ -822,28 +821,28 @@
   }
 }
 
-int PyUpb_CMessage_SetFieldValue(PyObject* _self, const upb_fielddef* field,
+int PyUpb_CMessage_SetFieldValue(PyObject* _self, const upb_FieldDef* field,
                                  PyObject* value, PyObject* exc) {
   PyUpb_CMessage* self = (void*)_self;
   assert(value);
 
-  if (upb_fielddef_issubmsg(field) || upb_fielddef_isseq(field)) {
+  if (upb_FieldDef_IsSubMessage(field) || upb_FieldDef_IsRepeated(field)) {
     PyErr_Format(exc,
                  "Assignment not allowed to message, map, or repeated "
                  "field \"%s\" in protocol message object.",
-                 upb_fielddef_name(field));
+                 upb_FieldDef_Name(field));
     return -1;
   }
 
   PyUpb_CMessage_EnsureReified(self);
 
-  upb_msgval val;
-  upb_arena* arena = PyUpb_Arena_Get(self->arena);
+  upb_MessageValue val;
+  upb_Arena* arena = PyUpb_Arena_Get(self->arena);
   if (!PyUpb_PyToUpb(value, field, &val, arena)) {
     return -1;
   }
 
-  upb_msg_set(self->ptr.msg, field, val, arena);
+  upb_Message_Set(self->ptr.msg, field, val, arena);
   return 0;
 }
 
@@ -866,7 +865,7 @@
   PyUpb_CMessage* self = (void*)_self;
 
   // Lookup field by name.
-  const upb_fielddef* field;
+  const upb_FieldDef* field;
   if (PyUpb_CMessage_LookupName(self, attr, &field, NULL, NULL)) {
     return PyUpb_CMessage_GetFieldValue(_self, field);
   }
@@ -898,34 +897,36 @@
 static int PyUpb_CMessage_SetAttr(PyObject* _self, PyObject* attr,
                                   PyObject* value) {
   PyUpb_CMessage* self = (void*)_self;
-  const upb_fielddef* field;
+  const upb_FieldDef* field;
   if (!PyUpb_CMessage_LookupName(self, attr, &field, NULL,
                                  PyExc_AttributeError)) {
     return -1;
   }
 
-  return PyUpb_CMessage_SetFieldValue(_self, field, value, PyExc_AttributeError);
+  return PyUpb_CMessage_SetFieldValue(_self, field, value,
+                                      PyExc_AttributeError);
 }
 
 static PyObject* PyUpb_CMessage_HasField(PyObject* _self, PyObject* arg) {
   PyUpb_CMessage* self = (void*)_self;
-  const upb_fielddef* field;
-  const upb_oneofdef* oneof;
+  const upb_FieldDef* field;
+  const upb_OneofDef* oneof;
 
   if (!PyUpb_CMessage_LookupName(self, arg, &field, &oneof, PyExc_ValueError)) {
     return NULL;
   }
 
-  if (field && !upb_fielddef_haspresence(field)) {
+  if (field && !upb_FieldDef_HasPresence(field)) {
     PyErr_Format(PyExc_ValueError, "Field %s does not have presence.",
-                 upb_fielddef_fullname(field));
+                 upb_FieldDef_FullName(field));
     return NULL;
   }
 
   if (PyUpb_CMessage_IsStub(self)) Py_RETURN_FALSE;
 
-  return PyBool_FromLong(field ? upb_msg_has(self->ptr.msg, field)
-                               : upb_msg_whichoneof(self->ptr.msg, oneof) != NULL);
+  return PyBool_FromLong(field ? upb_Message_Has(self->ptr.msg, field)
+                               : upb_Message_WhichOneof(self->ptr.msg, oneof) !=
+                                     NULL);
 }
 
 static PyObject* PyUpb_CMessage_FindInitializationErrors(PyObject* _self,
@@ -963,8 +964,8 @@
   } else {
     // We just need to return a boolean "true" or "false" for whether all
     // required fields are set.
-    const upb_msgdef* m = PyUpb_CMessage_GetMsgdef(_self);
-    const upb_symtab* symtab = upb_filedef_symtab(upb_msgdef_file(m));
+    const upb_MessageDef* m = PyUpb_CMessage_GetMsgdef(_self);
+    const upb_DefPool* symtab = upb_FileDef_Pool(upb_MessageDef_File(m));
     bool initialized = !upb_util_HasUnsetRequired(msg, m, symtab, NULL);
     return PyBool_FromLong(initialized);
   }
@@ -974,8 +975,8 @@
                                                   PyObject* val) {
   assert(PyTuple_Check(val));
   PyObject* field = PyTuple_GetItem(val, 0);
-  const upb_fielddef* f = PyUpb_FieldDescriptor_GetDef(field);
-  return PyLong_FromLong(upb_fielddef_number(f));
+  const upb_FieldDef* f = PyUpb_FieldDescriptor_GetDef(field);
+  return PyLong_FromLong(upb_FieldDef_Number(f));
 }
 
 static bool PyUpb_CMessage_SortFieldList(PyObject* list) {
@@ -993,7 +994,7 @@
   if (!call_result) goto err;
   ok = true;
 
- err:
+err:
   Py_XDECREF(method);
   Py_XDECREF(args);
   Py_XDECREF(kwargs);
@@ -1006,18 +1007,18 @@
   upb_msg* msg = PyUpb_CMessage_GetIfReified(_self);
   if (!msg) return list;
 
-  size_t iter1 = UPB_MSG_BEGIN;
-  const upb_msgdef* m = PyUpb_CMessage_GetMsgdef(_self);
-  const upb_symtab* symtab = upb_filedef_symtab(upb_msgdef_file(m));
-  const upb_fielddef* f;
+  size_t iter1 = kUpb_Message_Begin;
+  const upb_MessageDef* m = PyUpb_CMessage_GetMsgdef(_self);
+  const upb_DefPool* symtab = upb_FileDef_Pool(upb_MessageDef_File(m));
+  const upb_FieldDef* f;
   PyObject* field_desc = NULL;
   PyObject* py_val = NULL;
   PyObject* tuple = NULL;
-  upb_msgval val;
+  upb_MessageValue val;
   uint32_t last_field = 0;
   bool in_order = true;
-  while (upb_msg_next(msg, m, symtab, &f, &val, &iter1)) {
-    const uint32_t field_number = upb_fielddef_number(f);
+  while (upb_Message_Next(msg, m, symtab, &f, &val, &iter1)) {
+    const uint32_t field_number = upb_FieldDef_Number(f);
     if (field_number < last_field) in_order = false;
     last_field = field_number;
     PyObject* field_desc = PyUpb_FieldDescriptor_Get(f);
@@ -1094,11 +1095,12 @@
   }
 
   PyUpb_CMessage_EnsureReified(self);
-  const upb_msgdef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
-  const upb_filedef* file = upb_msgdef_file(msgdef);
-  const upb_extreg* extreg = upb_symtab_extreg(upb_filedef_symtab(file));
-  const upb_msglayout* layout = upb_msgdef_layout(msgdef);
-  upb_arena* arena = PyUpb_Arena_Get(self->arena);
+  const upb_MessageDef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
+  const upb_FileDef* file = upb_MessageDef_File(msgdef);
+  const upb_extreg* extreg =
+      upb_DefPool_ExtensionRegistry(upb_FileDef_Pool(file));
+  const upb_MiniTable* layout = upb_MessageDef_MiniTable(msgdef);
+  upb_Arena* arena = PyUpb_Arena_Get(self->arena);
   PyUpb_ModuleState* state = PyUpb_ModuleState_Get();
   int options =
       UPB_DECODE_MAXDEPTH(state->allow_oversize_protos ? UINT32_MAX : 100);
@@ -1136,7 +1138,7 @@
 
 static PyObject* PyUpb_CMessage_Clear(PyUpb_CMessage* self, PyObject* args) {
   PyUpb_CMessage_EnsureReified(self);
-  const upb_msgdef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
+  const upb_MessageDef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
   PyUpb_WeakMap* subobj_map = self->unset_subobj_map;
 
   if (subobj_map) {
@@ -1146,16 +1148,16 @@
     PyObject* obj;
 
     while (PyUpb_WeakMap_Next(subobj_map, &key, &obj, &iter)) {
-      const upb_fielddef* f = key;
+      const upb_FieldDef* f = key;
       PyUpb_WeakMap_DeleteIter(subobj_map, &iter);
-      if (upb_fielddef_ismap(f)) {
-        assert(upb_msg_get(msg, f).map_val == NULL);
+      if (upb_FieldDef_IsMap(f)) {
+        assert(upb_Message_Get(msg, f).map_val == NULL);
         PyUpb_MapContainer_Reify(obj, NULL);
-      } else if (upb_fielddef_isseq(f)) {
-        assert(upb_msg_get(msg, f).array_val == NULL);
+      } else if (upb_FieldDef_IsRepeated(f)) {
+        assert(upb_Message_Get(msg, f).array_val == NULL);
         PyUpb_RepeatedContainer_Reify(obj, NULL);
       } else {
-        assert(!upb_msg_has(msg, f));
+        assert(!upb_Message_Has(msg, f));
         PyUpb_CMessage* sub = (void*)obj;
         assert(self == sub->ptr.parent);
         PyUpb_CMessage_Reify(sub, f, NULL);
@@ -1163,11 +1165,11 @@
     }
   }
 
-  upb_msg_clear(self->ptr.msg, msgdef);
+  upb_Message_Clear(self->ptr.msg, msgdef);
   Py_RETURN_NONE;
 }
 
-void PyUpb_CMessage_DoClearField(PyObject* _self, const upb_fielddef* f) {
+void PyUpb_CMessage_DoClearField(PyObject* _self, const upb_FieldDef* f) {
   PyUpb_CMessage* self = (void*)_self;
   PyUpb_CMessage_EnsureReified((PyUpb_CMessage*)self);
 
@@ -1177,7 +1179,7 @@
                       ? PyUpb_WeakMap_Get(self->unset_subobj_map, f)
                       : NULL;
 
-  if (upb_fielddef_ismap(f)) {
+  if (upb_FieldDef_IsMap(f)) {
     // For maps we additionally have to invalidate any iterators.  So we need
     // to get an object even if it's reified.
     if (!sub) {
@@ -1185,24 +1187,24 @@
     }
     PyUpb_MapContainer_EnsureReified(sub);
     PyUpb_MapContainer_Invalidate(sub);
-  } else if (upb_fielddef_isseq(f)) {
+  } else if (upb_FieldDef_IsRepeated(f)) {
     if (sub) {
       PyUpb_RepeatedContainer_EnsureReified(sub);
     }
-  } else if (upb_fielddef_issubmsg(f)) {
+  } else if (upb_FieldDef_IsSubMessage(f)) {
     if (sub) {
       PyUpb_CMessage_EnsureReified((PyUpb_CMessage*)sub);
     }
   }
 
   Py_XDECREF(sub);
-  upb_msg_clearfield(self->ptr.msg, f);
+  upb_Message_ClearField(self->ptr.msg, f);
 }
 
 static PyObject* PyUpb_CMessage_ClearExtension(PyObject* _self, PyObject* arg) {
   PyUpb_CMessage* self = (void*)_self;
   PyUpb_CMessage_EnsureReified(self);
-  const upb_fielddef* f = PyUpb_CMessage_GetExtensionDef(_self, arg);
+  const upb_FieldDef* f = PyUpb_CMessage_GetExtensionDef(_self, arg);
   if (!f) return NULL;
   PyUpb_CMessage_DoClearField(_self, f);
   Py_RETURN_NONE;
@@ -1218,13 +1220,13 @@
   //   assert msg.HasField("foo")
   PyUpb_CMessage_EnsureReified(self);
 
-  const upb_fielddef* f;
-  const upb_oneofdef* o;
+  const upb_FieldDef* f;
+  const upb_OneofDef* o;
   if (!PyUpb_CMessage_LookupName(self, arg, &f, &o, PyExc_ValueError)) {
     return NULL;
   }
 
-  if (o) f = upb_msg_whichoneof(self->ptr.msg, o);
+  if (o) f = upb_Message_WhichOneof(self->ptr.msg, o);
   PyUpb_CMessage_DoClearField(_self, f);
   Py_RETURN_NONE;
 }
@@ -1232,8 +1234,8 @@
 static PyObject* PyUpb_CMessage_DiscardUnknownFields(PyUpb_CMessage* self,
                                                      PyObject* arg) {
   PyUpb_CMessage_EnsureReified(self);
-  const upb_msgdef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
-  upb_msg_discardunknown(self->ptr.msg, msgdef, 64);
+  const upb_MessageDef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
+  upb_Message_DiscardUnknown(self->ptr.msg, msgdef, 64);
   Py_RETURN_NONE;
 }
 
@@ -1241,8 +1243,8 @@
                                                          PyObject* arg) {
   PyUpb_CMessage* self = (void*)_self;
   upb_msg* msg = PyUpb_CMessage_GetIfReified(_self);
-  const upb_msgdef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
-  const upb_symtab* ext_pool = upb_filedef_symtab(upb_msgdef_file(msgdef));
+  const upb_MessageDef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
+  const upb_DefPool* ext_pool = upb_FileDef_Pool(upb_MessageDef_File(msgdef));
   upb_FieldPathEntry* fields;
   PyObject* ret = PyList_New(0);
   if (upb_util_HasUnsetRequired(msg, msgdef, ext_pool, &fields)) {
@@ -1287,43 +1289,43 @@
   goto done;
 }
 
-const upb_fielddef* PyUpb_CMessage_GetExtensionDef(PyObject* _self, PyObject* key) {
-  const upb_fielddef* f = PyUpb_FieldDescriptor_GetDef(key);
+const upb_FieldDef* PyUpb_CMessage_GetExtensionDef(PyObject* _self,
+                                                   PyObject* key) {
+  const upb_FieldDef* f = PyUpb_FieldDescriptor_GetDef(key);
   if (!f) {
     PyErr_Clear();
     PyErr_Format(PyExc_KeyError, "Object %R is not a field descriptor\n", key);
     return NULL;
   }
-  if (!upb_fielddef_isextension(f)) {
+  if (!upb_FieldDef_IsExtension(f)) {
     PyErr_Format(PyExc_KeyError, "Field %s is not an extension\n",
-                 upb_fielddef_fullname(f));
+                 upb_FieldDef_FullName(f));
     return NULL;
   }
-  const upb_msgdef* msgdef = PyUpb_CMessage_GetMsgdef(_self);
-  if (upb_fielddef_containingtype(f) != msgdef) {
+  const upb_MessageDef* msgdef = PyUpb_CMessage_GetMsgdef(_self);
+  if (upb_FieldDef_ContainingType(f) != msgdef) {
     PyErr_Format(PyExc_KeyError, "Extension doesn't match (%s vs %s)",
-                 upb_msgdef_fullname(msgdef), upb_fielddef_fullname(f));
+                 upb_MessageDef_FullName(msgdef), upb_FieldDef_FullName(f));
     return NULL;
   }
   return f;
 }
 
-
 static PyObject* PyUpb_CMessage_HasExtension(PyObject* _self,
                                              PyObject* ext_desc) {
   upb_msg* msg = PyUpb_CMessage_GetIfReified(_self);
-  const upb_fielddef* f = PyUpb_CMessage_GetExtensionDef(_self, ext_desc);
+  const upb_FieldDef* f = PyUpb_CMessage_GetExtensionDef(_self, ext_desc);
   if (!f) return NULL;
-  if (upb_fielddef_isseq(f)) {
+  if (upb_FieldDef_IsRepeated(f)) {
     PyErr_SetString(PyExc_KeyError,
                     "Field is repeated. A singular method is required.");
     return NULL;
   }
   if (!msg) Py_RETURN_FALSE;
-  return PyBool_FromLong(upb_msg_has(msg, f));
+  return PyBool_FromLong(upb_Message_Has(msg, f));
 }
 
-void PyUpb_CMessage_ReportInitializationErrors(const upb_msgdef* msgdef,
+void PyUpb_CMessage_ReportInitializationErrors(const upb_MessageDef* msgdef,
                                                PyObject* errors,
                                                PyObject* exc) {
   PyObject* comma = PyUnicode_FromString(",");
@@ -1332,7 +1334,7 @@
   missing_fields = PyUnicode_Join(comma, errors);
   if (!missing_fields) goto done;
   PyErr_Format(exc, "Message %s is missing required fields: %U",
-               upb_msgdef_fullname(msgdef), missing_fields);
+               upb_MessageDef_FullName(msgdef), missing_fields);
 done:
   Py_XDECREF(comma);
   Py_XDECREF(missing_fields);
@@ -1351,7 +1353,7 @@
     return NULL;
   }
 
-  const upb_msgdef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
+  const upb_MessageDef* msgdef = _PyUpb_CMessage_GetMsgdef(self);
   if (PyUpb_CMessage_IsStub(self)) {
     // Nothing to serialize, but we do have to check whether the message is
     // initialized.
@@ -1367,14 +1369,14 @@
     return NULL;
   }
 
-  upb_arena* arena = upb_arena_new();
-  const upb_msglayout* layout = upb_msgdef_layout(msgdef);
+  upb_Arena* arena = upb_Arena_New();
+  const upb_MiniTable* layout = upb_MessageDef_MiniTable(msgdef);
   size_t size = 0;
   // Python does not currently have any effective limit on serialization depth.
   int options = UPB_ENCODE_MAXDEPTH(UINT32_MAX);
-  if (check_required) options |= UPB_ENCODE_CHECKREQUIRED;
-  if (deterministic) options |= UPB_ENCODE_DETERMINISTIC;
-  char* pb = upb_encode_ex(self->ptr.msg, layout, options, arena, &size);
+  if (check_required) options |= kUpb_Encode_CheckRequired;
+  if (deterministic) options |= kUpb_Encode_Deterministic;
+  char* pb = upb_EncodeEx(self->ptr.msg, layout, options, arena, &size);
   PyObject* ret = NULL;
 
   if (!pb) {
@@ -1392,7 +1394,7 @@
   ret = PyBytes_FromStringAndSize(pb, size);
 
 done:
-  upb_arena_free(arena);
+  upb_Arena_Free(arena);
   return ret;
 }
 
@@ -1409,15 +1411,15 @@
 
 static PyObject* PyUpb_CMessage_WhichOneof(PyObject* _self, PyObject* name) {
   PyUpb_CMessage* self = (void*)_self;
-  const upb_oneofdef* o;
+  const upb_OneofDef* o;
   if (!PyUpb_CMessage_LookupName(self, name, NULL, &o, PyExc_ValueError)) {
     return NULL;
   }
   upb_msg* msg = PyUpb_CMessage_GetIfReified(_self);
   if (!msg) Py_RETURN_NONE;
-  const upb_fielddef* f = upb_msg_whichoneof(msg, o);
+  const upb_FieldDef* f = upb_Message_WhichOneof(msg, o);
   if (!f) Py_RETURN_NONE;
-  return PyUnicode_FromString(upb_fielddef_name(f));
+  return PyUnicode_FromString(upb_FieldDef_Name(f));
 }
 
 void PyUpb_CMessage_ClearExtensionDict(PyObject* _self) {
@@ -1433,8 +1435,8 @@
     return self->ext_dict;
   }
 
-  const upb_msgdef* m = _PyUpb_CMessage_GetMsgdef(self);
-  if (upb_msgdef_extrangecount(m) == 0) {
+  const upb_MessageDef* m = _PyUpb_CMessage_GetMsgdef(self);
+  if (upb_MessageDef_ExtensionRangeCount(m) == 0) {
     PyErr_SetNone(PyExc_AttributeError);
     return NULL;
   }
@@ -1544,7 +1546,7 @@
 // to simplify this, so that the illustration above is indeed accurate).
 
 typedef struct {
-  const upb_msglayout* layout;
+  const upb_MiniTable* layout;
   PyObject* py_message_descriptor;
 } PyUpb_MessageMeta;
 
@@ -1559,7 +1561,7 @@
   return (PyUpb_MessageMeta*)((char*)cls + cpython_bits.type_basicsize);
 }
 
-static const upb_msgdef* PyUpb_MessageMeta_GetMsgdef(PyObject* cls) {
+static const upb_MessageDef* PyUpb_MessageMeta_GetMsgdef(PyObject* cls) {
   PyUpb_MessageMeta* self = PyUpb_GetMessageMeta(cls);
   return PyUpb_Descriptor_GetDef(self->py_message_descriptor);
 }
@@ -1572,9 +1574,9 @@
     return PyErr_Format(PyExc_TypeError, "Expected a message Descriptor");
   }
 
-  const upb_msgdef* msgdef = PyUpb_Descriptor_GetDef(py_descriptor);
+  const upb_MessageDef* msgdef = PyUpb_Descriptor_GetDef(py_descriptor);
   assert(msgdef);
-  assert(!PyUpb_ObjCache_Get(upb_msgdef_layout(msgdef)));
+  assert(!PyUpb_ObjCache_Get(upb_MessageDef_MiniTable(msgdef)));
 
   PyObject* slots = PyTuple_New(0);
   if (PyDict_SetItemString(dict, "__slots__", slots) < 0) {
@@ -1586,7 +1588,7 @@
   //    (CMessage, Message, WktBase)   # For well-known types
   PyObject* wkt_bases = PyUpb_GetWktBases(state);
   PyObject* wkt_base =
-      PyDict_GetItemString(wkt_bases, upb_msgdef_fullname(msgdef));
+      PyDict_GetItemString(wkt_bases, upb_MessageDef_FullName(msgdef));
   PyObject* args;
   if (wkt_base == NULL) {
     args = Py_BuildValue("s(OO)O", name, state->cmessage_type,
@@ -1602,10 +1604,10 @@
 
   PyUpb_MessageMeta* meta = PyUpb_GetMessageMeta(ret);
   meta->py_message_descriptor = py_descriptor;
-  meta->layout = upb_msgdef_layout(msgdef);
+  meta->layout = upb_MessageDef_MiniTable(msgdef);
   Py_INCREF(meta->py_message_descriptor);
 
-  PyUpb_ObjCache_Add(upb_msgdef_layout(msgdef), ret);
+  PyUpb_ObjCache_Add(upb_MessageDef_MiniTable(msgdef), ret);
 
   return ret;
 }
@@ -1641,8 +1643,8 @@
     return NULL;
   }
 
-  const upb_msgdef* m = PyUpb_Descriptor_GetDef(py_descriptor);
-  PyObject* ret = PyUpb_ObjCache_Get(upb_msgdef_layout(m));
+  const upb_MessageDef* m = PyUpb_Descriptor_GetDef(py_descriptor);
+  PyObject* ret = PyUpb_ObjCache_Get(upb_MessageDef_MiniTable(m));
   if (ret) return ret;
   return PyUpb_MessageMeta_DoCreateClass(py_descriptor, name, dict);
 }
@@ -1654,11 +1656,11 @@
   PyUpb_Dealloc(self);
 }
 
-void PyUpb_MessageMeta_AddFieldNumber(PyObject* self, const upb_fielddef* f) {
+void PyUpb_MessageMeta_AddFieldNumber(PyObject* self, const upb_FieldDef* f) {
   PyObject* name =
-      PyUnicode_FromFormat("%s_FIELD_NUMBER", upb_fielddef_name(f));
+      PyUnicode_FromFormat("%s_FIELD_NUMBER", upb_FieldDef_Name(f));
   PyObject* upper = PyObject_CallMethod(name, "upper", "");
-  PyObject_SetAttr(self, upper, PyLong_FromLong(upb_fielddef_number(f)));
+  PyObject_SetAttr(self, upper, PyLong_FromLong(upb_FieldDef_Number(f)));
   Py_DECREF(name);
   Py_DECREF(upper);
 }
@@ -1666,48 +1668,49 @@
 static PyObject* PyUpb_MessageMeta_GetDynamicAttr(PyObject* self,
                                                   PyObject* name) {
   const char* name_buf = PyUpb_GetStrData(name);
-  const upb_msgdef* msgdef = PyUpb_MessageMeta_GetMsgdef(self);
-  const upb_filedef* filedef = upb_msgdef_file(msgdef);
-  const upb_symtab* symtab = upb_filedef_symtab(filedef);
+  const upb_MessageDef* msgdef = PyUpb_MessageMeta_GetMsgdef(self);
+  const upb_FileDef* filedef = upb_MessageDef_File(msgdef);
+  const upb_DefPool* symtab = upb_FileDef_Pool(filedef);
 
   PyObject* py_key =
-      PyBytes_FromFormat("%s.%s", upb_msgdef_fullname(msgdef), name_buf);
+      PyBytes_FromFormat("%s.%s", upb_MessageDef_FullName(msgdef), name_buf);
   const char* key = PyUpb_GetStrData(py_key);
   PyObject* ret = NULL;
-  const upb_msgdef* nested = upb_symtab_lookupmsg(symtab, key);
-  const upb_enumdef* enumdef;
-  const upb_enumvaldef* enumval;
-  const upb_fielddef* ext;
+  const upb_MessageDef* nested = upb_DefPool_FindMessageByName(symtab, key);
+  const upb_EnumDef* enumdef;
+  const upb_EnumValueDef* enumval;
+  const upb_FieldDef* ext;
 
   if (nested) {
     ret = PyUpb_Descriptor_GetClass(nested);
-  } else if ((enumdef = upb_symtab_lookupenum(symtab, key))) {
+  } else if ((enumdef = upb_DefPool_FindEnumByName(symtab, key))) {
     PyUpb_ModuleState* state = PyUpb_ModuleState_Get();
     PyObject* klass = state->enum_type_wrapper_class;
     ret = PyUpb_EnumDescriptor_Get(enumdef);
     ret = PyObject_CallFunctionObjArgs(klass, ret, NULL);
-  } else if ((enumval = upb_symtab_lookupenumval(symtab, key))) {
-    ret = PyLong_FromLong(upb_enumvaldef_number(enumval));
-  } else if ((ext = upb_symtab_lookupext(symtab, key))) {
+  } else if ((enumval = upb_DefPool_FindEnumByNameval(symtab, key))) {
+    ret = PyLong_FromLong(upb_EnumValueDef_Number(enumval));
+  } else if ((ext = upb_DefPool_FindExtensionByName(symtab, key))) {
     ret = PyUpb_FieldDescriptor_Get(ext);
   }
 
   Py_DECREF(py_key);
 
-  const char* suffix =  "_FIELD_NUMBER";
+  const char* suffix = "_FIELD_NUMBER";
   size_t n = strlen(name_buf);
   size_t suffix_n = strlen(suffix);
   if (n > suffix_n && memcmp(suffix, name_buf + n - suffix_n, suffix_n) == 0) {
     // We can't look up field names dynamically, because the <NAME>_FIELD_NUMBER
     // naming scheme upper-cases the field name and is therefore non-reversible.
     // So we just add all field numbers.
-    int n = upb_msgdef_fieldcount(msgdef);
+    int n = upb_MessageDef_FieldCount(msgdef);
     for (int i = 0; i < n; i++) {
-      PyUpb_MessageMeta_AddFieldNumber(self, upb_msgdef_field(msgdef, i));
+      PyUpb_MessageMeta_AddFieldNumber(self, upb_MessageDef_Field(msgdef, i));
     }
-    n = upb_msgdef_nestedextcount(msgdef);
+    n = upb_MessageDef_NestedExtensionCount(msgdef);
     for (int i = 0; i < n; i++) {
-      PyUpb_MessageMeta_AddFieldNumber(self, upb_msgdef_nestedext(msgdef, i));
+      PyUpb_MessageMeta_AddFieldNumber(
+          self, upb_MessageDef_NestedExtension(msgdef, i));
     }
     ret = PyObject_GenericGetAttr(self, name);
   }
@@ -1772,8 +1775,8 @@
 
   if (!state->cmessage_type || !state->message_meta_type) return false;
   if (PyModule_AddObject(m, "MessageMeta", message_meta_type)) return false;
-  state->listfields_item_key =
-      PyObject_GetAttrString((PyObject*)state->cmessage_type, "_ListFieldsItemKey");
+  state->listfields_item_key = PyObject_GetAttrString(
+      (PyObject*)state->cmessage_type, "_ListFieldsItemKey");
 
   PyObject* mod = PyImport_ImportModule("google.protobuf.message");
   if (mod == NULL) return false;