New upb_msg code and Lua bindings around it.

There are still some things that are unfinished,
but we are at parity with what Lua had before.

1 files changed, 18 insertions, 1957 deletions

diff --git a/upb/bindings/lua/upb.c b/upb/bindings/lua/upb.c
index 1483676..38fd24a 100644
--- a/upb/bindings/lua/upb.c
+++ b/upb/bindings/lua/upb.c
@@ -27,25 +27,8 @@
 #include "lauxlib.h"
 #include "upb/bindings/lua/upb.h"
 #include "upb/handlers.h"
-#include "upb/pb/glue.h"
-#include "upb/shim/shim.h"
+#include "upb/msg.h"
 
-/* Lua metatable types. */
-#define LUPB_ENUMDEF "lupb.enumdef"
-#define LUPB_FIELDDEF "lupb.fielddef"
-#define LUPB_FILEDEF "lupb.filedef"
-#define LUPB_MSGDEF "lupb.msgdef"
-#define LUPB_ONEOFDEF "lupb.oneof"
-#define LUPB_SYMTAB "lupb.symtab"
-
-#define LUPB_ARRAY "lupb.array"
-#define LUPB_MSG "lupb.msg"
-
-/* Other table constants. */
-#define LUPB_OBJCACHE "lupb.objcache"
-
-static void lupb_msgdef_init(lua_State *L);
-static size_t lupb_msgdef_sizeof();
 
 /* Lua compatibility code *****************************************************/
 
@@ -74,8 +57,6 @@ static void lupb_newlib(lua_State *L, const char *name, const luaL_Reg *funcs) {
   luaL_register(L, name, funcs);
 }
 
-#define lupb_setfuncs(L, l) luaL_register(L, NULL, l)
-
 #elif LUA_VERSION_NUM == 502
 
 int luaL_typerror(lua_State *L, int narg, const char *tname) {
@@ -95,8 +76,6 @@ static void lupb_newlib(lua_State *L, const char *name, const luaL_Reg *funcs) {
   luaL_setfuncs(L, funcs, 0);
 }
 
-#define lupb_setfuncs(L, l) luaL_setfuncs(L, l, 0)
-
 #else
 #error Only Lua 5.1 and 5.2 are supported
 #endif
@@ -133,30 +112,17 @@ bool lupb_openlib(lua_State *L, void *ptr, const char *name,
   return false;
 }
 
-/* Pushes a new userdata with the given metatable and ensures that it has a
- * uservalue. */
-static void *newudata_with_userval(lua_State *L, size_t size,
-                                   const char *type) {
-  void *ret = lua_newuserdata(L, size);
-
-  /* Set metatable. */
-  luaL_getmetatable(L, type);
-  UPB_ASSERT(!lua_isnil(L, -1));  /* Should have been created by luaopen_upb. */
-  lua_setmetatable(L, -2);
-
-  lua_newtable(L);
-  lua_setuservalue(L, -2);
-
-  return ret;
+void lupb_checkstatus(lua_State *L, upb_status *s) {
+  if (!upb_ok(s)) {
+    lua_pushstring(L, upb_status_errmsg(s));
+    lua_error(L);
+  }
 }
 
-const char *lupb_checkname(lua_State *L, int narg) {
-  size_t len;
-  const char *name = luaL_checklstring(L, narg, &len);
-  if (strlen(name) != len)
-    luaL_error(L, "names cannot have embedded NULLs");
-  return name;
-}
+/* Scalar type mapping ********************************************************/
+
+/* Functions that convert scalar/primitive values (numbers, strings, bool)
+ * between Lua and C/upb.  Handles type/range checking. */
 
 bool lupb_checkbool(lua_State *L, int narg) {
   if (!lua_isboolean(L, narg)) {
@@ -167,9 +133,12 @@ bool lupb_checkbool(lua_State *L, int narg) {
 
 /* Unlike luaL_checkstring(), this does not allow implicit conversion to
  * string. */
-void lupb_checkstring(lua_State *L, int narg) {
-  if (lua_type(L, narg) != LUA_TSTRING)
+const char *lupb_checkstring(lua_State *L, int narg, size_t *len) {
+  if (lua_type(L, narg) != LUA_TSTRING) {
     luaL_error(L, "Expected string");
+  }
+
+  return lua_tolstring(L, narg, len);
 }
 
 /* Unlike luaL_checkinteger, these do not implicitly convert from string or
@@ -235,1839 +204,19 @@ void lupb_pushfloat(lua_State *L, float d) {
   lua_pushnumber(L, d);
 }
 
-static void lupb_checkval(lua_State *L, int narg, upb_fieldtype_t type) {
-  switch(type) {
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_ENUM:
-      lupb_checkint32(L, narg);
-      break;
-    case UPB_TYPE_INT64:
-      lupb_checkint64(L, narg);
-      break;
-    case UPB_TYPE_UINT32:
-      lupb_checkuint32(L, narg);
-      break;
-    case UPB_TYPE_UINT64:
-      lupb_checkuint64(L, narg);
-      break;
-    case UPB_TYPE_DOUBLE:
-      lupb_checkdouble(L, narg);
-      break;
-    case UPB_TYPE_FLOAT:
-      lupb_checkfloat(L, narg);
-      break;
-    case UPB_TYPE_BOOL:
-      lupb_checkbool(L, narg);
-      break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-      lupb_checkstring(L, narg);
-      break;
-    case UPB_TYPE_MESSAGE:
-      lupb_assert(L, false);
-  }
-}
-
-void lupb_checkstatus(lua_State *L, upb_status *s) {
-  if (!upb_ok(s)) {
-    lua_pushstring(L, upb_status_errmsg(s));
-    lua_error(L);
-  }
-}
-
-static upb_fieldtype_t lupb_checkfieldtype(lua_State *L, int narg) {
-  int type = luaL_checkint(L, narg);
-  if (!upb_fielddef_checktype(type))
-    luaL_argerror(L, narg, "invalid field type");
-  return type;
-}
-
-#define CHK(pred) do { \
-    upb_status status = UPB_STATUS_INIT; \
-    pred; \
-    lupb_checkstatus(L, &status); \
-  } while (0)
-
-
-/* lupb_refcounted ************************************************************/
-
-/* All upb objects that use upb_refcounted have a userdata that begins with a
- * pointer to that object.  Each type has its own metatable.  Objects are cached
- * in a weak table indexed by the C pointer of the object they are caching.
- *
- * Note that we consistently use memcpy() to read to/from the object.  This
- * allows the userdata to use its own struct without violating aliasing, as
- * long as it begins with a pointer. */
-
-/* Checks type; if it matches, pulls the pointer out of the wrapper. */
-void *lupb_refcounted_check(lua_State *L, int narg, const char *type) {
-  void *ud = luaL_checkudata(L, narg, type);
-  void *ret;
-  memcpy(&ret, ud, sizeof ret);
-  if (!ret) luaL_error(L, "called into dead object");
-  return ret;
-}
-
-bool lupb_refcounted_pushwrapper(lua_State *L, const upb_refcounted *obj,
-                                 const char *type, const void *ref_donor,
-                                 size_t size) {
-  bool create;
-  void *ud;
-
-  if (obj == NULL) {
-    lua_pushnil(L);
-    return false;
-  }
-
-  /* Lookup our cache in the registry (we don't put our objects in the registry
-   * directly because we need our cache to be a weak table). */
-  lua_getfield(L, LUA_REGISTRYINDEX, LUPB_OBJCACHE);
-  UPB_ASSERT(!lua_isnil(L, -1));  /* Should have been created by luaopen_upb. */
-  lua_pushlightuserdata(L, (void*)obj);
-  lua_rawget(L, -2);
-  /* Stack is now: objcache, cached value. */
-
-  create = false;
-
-  if (lua_isnil(L, -1)) {
-    create = true;
-  } else {
-    void *ud = lua_touserdata(L, -1);
-    void *ud_obj;
-    lupb_assert(L, ud);
-    memcpy(&ud_obj, ud, sizeof(void*));
-
-    /* A corner case: it is possible for the value to be GC'd
-     * already, in which case we should evict this entry and create
-     * a new one. */
-    if (ud_obj == NULL) {
-      create = true;
-    }
-  }
-
-  ud = NULL;
-
-  if (create) {
-    /* Remove bad cached value and push new value. */
-    lua_pop(L, 1);
-
-    /* All of our userdata begin with a pointer to the obj. */
-    ud = lua_newuserdata(L, size);
-    memcpy(ud, &obj, sizeof(void*));
-    upb_refcounted_donateref(obj, ref_donor, ud);
-
-    luaL_getmetatable(L, type);
-    /* Should have been created by luaopen_upb. */
-    lupb_assert(L, !lua_isnil(L, -1));
-    lua_setmetatable(L, -2);
-
-    /* Set it in the cache. */
-    lua_pushlightuserdata(L, (void*)obj);
-    lua_pushvalue(L, -2);
-    lua_rawset(L, -4);
-  } else {
-    /* Existing wrapper obj already has a ref. */
-    ud = lua_touserdata(L, -1);
-    upb_refcounted_checkref(obj, ud);
-    if (ref_donor)
-      upb_refcounted_unref(obj, ref_donor);
-  }
-
-  lua_insert(L, -2);
-  lua_pop(L, 1);
-  return create;
-}
-
-void lupb_refcounted_pushnewrapper(lua_State *L, const upb_refcounted *obj,
-                                   const char *type, const void *ref_donor) {
-  bool created =
-      lupb_refcounted_pushwrapper(L, obj, type, ref_donor, sizeof(void *));
-  UPB_ASSERT(created == true);
-}
-
-static int lupb_refcounted_gc(lua_State *L) {
-  void *ud = lua_touserdata(L, 1);
-  void *nullp;
-  upb_refcounted *obj;
-  memcpy(&obj, ud, sizeof(obj));
-  upb_refcounted_unref(obj, ud);
-
-  /* Zero out pointer so we can detect a call into a GC'd object. */
-  nullp = NULL;
-  memcpy(ud, &nullp, sizeof(nullp));
-
-  return 0;
-}
-
-static const struct luaL_Reg lupb_refcounted_mm[] = {
-  {"__gc", lupb_refcounted_gc},
-  {NULL, NULL}
-};
-
-
-/* lupb_def *******************************************************************/
-
-static const upb_def *lupb_def_check(lua_State *L, int narg) {
-  upb_def *ret;
-  void *ud = luaL_testudata(L, narg, LUPB_MSGDEF);
-  if (!ud) ud = luaL_testudata(L, narg, LUPB_ENUMDEF);
-  if (!ud) ud = luaL_testudata(L, narg, LUPB_FIELDDEF);
-  if (!ud) luaL_typerror(L, narg, "upb def");
-
-  memcpy(&ret, ud, sizeof ret);
-  if (!ret) luaL_error(L, "called into dead object");
-  return ret;
-}
-
-static upb_def *lupb_def_checkmutable(lua_State *L, int narg) {
-  const upb_def *def = lupb_def_check(L, narg);
-  if (upb_def_isfrozen(def))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_def*)def;
-}
-
-bool lupb_def_pushwrapper(lua_State *L, const upb_def *def,
-                          const void *ref_donor) {
-  const char *type = NULL;
-  size_t size = sizeof(void*);
-  bool created;
-
-  if (def == NULL) {
-    lua_pushnil(L);
-    return false;
-  }
-
-  switch (upb_def_type(def)) {
-    case UPB_DEF_MSG: {
-      type = LUPB_MSGDEF;
-      size = lupb_msgdef_sizeof();
-      break;
-    }
-    case UPB_DEF_ENUM: type = LUPB_ENUMDEF; break;
-    case UPB_DEF_FIELD: type = LUPB_FIELDDEF; break;
-    default: luaL_error(L, "unknown deftype %d", upb_def_type(def));
-  }
-
-  created =
-      lupb_refcounted_pushwrapper(L, upb_def_upcast(def), type, ref_donor, size);
-
-  if (created && upb_def_type(def) == UPB_DEF_MSG) {
-    lupb_msgdef_init(L);
-  }
-
-  return created;
-}
-
-void lupb_def_pushnewrapper(lua_State *L, const upb_def *def,
-                            const void *ref_donor) {
-  bool created = lupb_def_pushwrapper(L, def, ref_donor);
-  UPB_ASSERT(created == true);
-}
-
-static int lupb_def_type(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushinteger(L, upb_def_type(def));
-  return 1;
-}
-
-static int lupb_def_freeze(lua_State *L) {
-  upb_def *def = lupb_def_checkmutable(L, 1);
-  CHK(upb_def_freeze(&def, 1, &status));
-  return 0;
-}
-
-static int lupb_def_isfrozen(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushboolean(L, upb_def_isfrozen(def));
-  return 1;
-}
-
-static int lupb_def_fullname(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushstring(L, upb_def_fullname(def));
-  return 1;
-}
-
-static int lupb_def_name(lua_State *L) {
-  const upb_def *def = lupb_def_check(L, 1);
-  lua_pushstring(L, upb_def_name(def));
-  return 1;
-}
-
-static int lupb_def_setfullname(lua_State *L) {
-  const char *name = lupb_checkname(L, 2);
-  CHK(upb_def_setfullname(lupb_def_checkmutable(L, 1), name, &status));
-  return 0;
-}
-
-#define LUPB_COMMON_DEF_METHODS \
-  {"def_type", lupb_def_type},  \
-  {"full_name", lupb_def_fullname}, \
-  {"freeze", lupb_def_freeze}, \
-  {"is_frozen", lupb_def_isfrozen}, \
-  {"name", lupb_def_name}, \
-  {"set_full_name", lupb_def_setfullname}, \
-
-
-/* lupb_fielddef **************************************************************/
-
-void lupb_fielddef_pushwrapper(lua_State *L, const upb_fielddef *f,
-                               const void *ref_donor) {
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(f), ref_donor);
-}
-
-const upb_fielddef *lupb_fielddef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_FIELDDEF);
-}
-
-static upb_fielddef *lupb_fielddef_checkmutable(lua_State *L, int narg) {
-  const upb_fielddef *f = lupb_fielddef_check(L, narg);
-  if (upb_fielddef_isfrozen(f))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_fielddef*)f;
-}
-
-static int lupb_fielddef_new(lua_State *L) {
-  upb_fielddef *f = upb_fielddef_new(&f);
-  lupb_def_pushnewrapper(L, upb_fielddef_upcast(f), &f);
-  return 1;
-}
-
-/* Getters */
-
-static int lupb_fielddef_containingtype(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lupb_msgdef_pushwrapper(L, upb_fielddef_containingtype(f), NULL);
-  return 1;
-}
-
-static int lupb_fielddef_containingtypename(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  lua_pushstring(L, upb_fielddef_containingtypename(f));
-  return 1;
-}
-
-static int lupb_fielddef_default(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_INT32:
-    int32:
-      lupb_pushint32(L, upb_fielddef_defaultint32(f)); break;
-    case UPB_TYPE_INT64:
-      lupb_pushint64(L, upb_fielddef_defaultint64(f)); break;
-    case UPB_TYPE_UINT32:
-      lupb_pushuint32(L, upb_fielddef_defaultuint32(f)); break;
-    case UPB_TYPE_UINT64:
-      lupb_pushuint64(L, upb_fielddef_defaultuint64(f)); break;
-    case UPB_TYPE_DOUBLE:
-      lua_pushnumber(L, upb_fielddef_defaultdouble(f)); break;
-    case UPB_TYPE_FLOAT:
-      lua_pushnumber(L, upb_fielddef_defaultfloat(f)); break;
-    case UPB_TYPE_BOOL:
-      lua_pushboolean(L, upb_fielddef_defaultbool(f)); break;
-    case UPB_TYPE_ENUM:
-      if (upb_fielddef_enumhasdefaultstr(f)) {
-        goto str;
-      } else if (upb_fielddef_enumhasdefaultint32(f)) {
-        goto int32;
-      } else {
-        lua_pushnil(L);
-      }
-      break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-    str: {
-      size_t len;
-      const char *data = upb_fielddef_defaultstr(f, &len);
-      lua_pushlstring(L, data, len);
-      break;
-    }
-    case UPB_TYPE_MESSAGE:
-      return luaL_error(L, "Message fields do not have explicit defaults.");
-  }
-  return 1;
-}
-
-static int lupb_fielddef_getsel(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  upb_selector_t sel;
-  if (upb_handlers_getselector(f, luaL_checknumber(L, 2), &sel)) {
-    lua_pushinteger(L, sel);
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-static int lupb_fielddef_hassubdef(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushboolean(L, upb_fielddef_hassubdef(f));
-  return 1;
-}
-
-static int lupb_fielddef_index(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushinteger(L, upb_fielddef_index(f));
-  return 1;
-}
-
-static int lupb_fielddef_intfmt(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushinteger(L, upb_fielddef_intfmt(f));
-  return 1;
-}
-
-static int lupb_fielddef_isextension(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushboolean(L, upb_fielddef_isextension(f));
-  return 1;
-}
-
-static int lupb_fielddef_istagdelim(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushboolean(L, upb_fielddef_istagdelim(f));
-  return 1;
-}
-
-static int lupb_fielddef_label(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushinteger(L, upb_fielddef_label(f));
-  return 1;
-}
-
-static int lupb_fielddef_lazy(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushboolean(L, upb_fielddef_lazy(f));
-  return 1;
-}
-
-static int lupb_fielddef_name(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushstring(L, upb_fielddef_name(f));
-  return 1;
-}
-
-static int lupb_fielddef_number(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  int32_t num = upb_fielddef_number(f);
-  if (num)
-    lua_pushinteger(L, num);
-  else
-    lua_pushnil(L);
-  return 1;
-}
-
-static int lupb_fielddef_packed(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  lua_pushboolean(L, upb_fielddef_packed(f));
-  return 1;
-}
-
-static int lupb_fielddef_subdef(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  const upb_def *def;
-
-  if (!upb_fielddef_hassubdef(f))
-    luaL_error(L, "Tried to get subdef of non-message field");
-  def = upb_fielddef_subdef(f);
-  lupb_def_pushwrapper(L, def, NULL);
-  return 1;
-}
-
-static int lupb_fielddef_subdefname(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  if (!upb_fielddef_hassubdef(f))
-    luaL_error(L, "Tried to get subdef name of non-message field");
-  lua_pushstring(L, upb_fielddef_subdefname(f));
-  return 1;
-}
-
-static int lupb_fielddef_type(lua_State *L) {
-  const upb_fielddef *f = lupb_fielddef_check(L, 1);
-  if (upb_fielddef_typeisset(f))
-    lua_pushinteger(L, upb_fielddef_type(f));
-  else
-    lua_pushnil(L);
-  return 1;
-}
-
-/* Setters */
-
-static int lupb_fielddef_setcontainingtypename(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  const char *name = NULL;
-  if (!lua_isnil(L, 2))
-    name = lupb_checkname(L, 2);
-  CHK(upb_fielddef_setcontainingtypename(f, name, &status));
-  return 0;
-}
-
-static int lupb_fielddef_setdefault(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_INT32:
-      upb_fielddef_setdefaultint32(f, lupb_checkint32(L, 2));
-      break;
-    case UPB_TYPE_INT64:
-      upb_fielddef_setdefaultint64(f, lupb_checkint64(L, 2));
-      break;
-    case UPB_TYPE_UINT32:
-      upb_fielddef_setdefaultuint32(f, lupb_checkuint32(L, 2));
-      break;
-    case UPB_TYPE_UINT64:
-      upb_fielddef_setdefaultuint64(f, lupb_checkuint64(L, 2));
-      break;
-    case UPB_TYPE_DOUBLE:
-      upb_fielddef_setdefaultdouble(f, lupb_checkdouble(L, 2));
-      break;
-    case UPB_TYPE_FLOAT:
-      upb_fielddef_setdefaultfloat(f, lupb_checkfloat(L, 2));
-      break;
-    case UPB_TYPE_BOOL:
-      upb_fielddef_setdefaultbool(f, lupb_checkbool(L, 2));
-      break;
-    case UPB_TYPE_MESSAGE:
-      return luaL_error(L, "Message types cannot have defaults.");
-    case UPB_TYPE_ENUM:
-      if (lua_type(L, 2) != LUA_TSTRING) {
-        upb_fielddef_setdefaultint32(f, lupb_checkint32(L, 2));
-        break;
-      }
-      /* Else fall through and set string default. */
-    case UPB_TYPE_BYTES:
-    case UPB_TYPE_STRING: {
-      size_t len;
-      const char *str = lua_tolstring(L, 2, &len);
-      CHK(upb_fielddef_setdefaultstr(f, str, len, &status));
-    }
-  }
-  return 0;
-}
-
-static int lupb_fielddef_setisextension(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  CHK(upb_fielddef_setisextension(f, lupb_checkbool(L, 2)));
-  return 0;
-}
-
-static int lupb_fielddef_setlabel(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  int label = luaL_checkint(L, 2);
-  if (!upb_fielddef_checklabel(label))
-    luaL_argerror(L, 2, "invalid field label");
-  upb_fielddef_setlabel(f, label);
-  return 0;
-}
-
-static int lupb_fielddef_setlazy(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  upb_fielddef_setlazy(f, lupb_checkbool(L, 2));
-  return 0;
-}
-
-static int lupb_fielddef_setname(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  CHK(upb_fielddef_setname(f, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
-static int lupb_fielddef_setnumber(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  CHK(upb_fielddef_setnumber(f, luaL_checkint(L, 2), &status));
-  return 0;
-}
-
-static int lupb_fielddef_setpacked(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  upb_fielddef_setpacked(f, lupb_checkbool(L, 2));
-  return 0;
-}
-
-static int lupb_fielddef_setsubdef(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  const upb_def *def = NULL;
-  if (!lua_isnil(L, 2))
-    def = lupb_def_check(L, 2);
-  CHK(upb_fielddef_setsubdef(f, def, &status));
-  return 0;
-}
-
-static int lupb_fielddef_setsubdefname(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  const char *name = NULL;
-  if (!lua_isnil(L, 2))
-    name = lupb_checkname(L, 2);
-  CHK(upb_fielddef_setsubdefname(f, name, &status));
-  return 0;
-}
-
-static int lupb_fielddef_settype(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  upb_fielddef_settype(f, lupb_checkfieldtype(L, 2));
-  return 0;
-}
-
-static int lupb_fielddef_setintfmt(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  int32_t intfmt = luaL_checknumber(L, 2);
-  if (!upb_fielddef_checkintfmt(intfmt))
-    luaL_argerror(L, 2, "invalid intfmt");
-  upb_fielddef_setintfmt(f, intfmt);
-  return 0;
-}
-
-static int lupb_fielddef_settagdelim(lua_State *L) {
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 1);
-  bool is_tag_delim = lupb_checkbool(L, 2);
-  CHK(upb_fielddef_settagdelim(f, is_tag_delim));
-  return 0;
-}
-
-static const struct luaL_Reg lupb_fielddef_m[] = {
-  LUPB_COMMON_DEF_METHODS
-
-  {"containing_type", lupb_fielddef_containingtype},
-  {"containing_type_name", lupb_fielddef_containingtypename},
-  {"default", lupb_fielddef_default},
-  {"getsel", lupb_fielddef_getsel},
-  {"has_subdef", lupb_fielddef_hassubdef},
-  {"index", lupb_fielddef_index},
-  {"intfmt", lupb_fielddef_intfmt},
-  {"is_extension", lupb_fielddef_isextension},
-  {"istagdelim", lupb_fielddef_istagdelim},
-  {"label", lupb_fielddef_label},
-  {"lazy", lupb_fielddef_lazy},
-  {"name", lupb_fielddef_name},
-  {"number", lupb_fielddef_number},
-  {"packed", lupb_fielddef_packed},
-  {"subdef", lupb_fielddef_subdef},
-  {"subdef_name", lupb_fielddef_subdefname},
-  {"type", lupb_fielddef_type},
-
-  {"set_containing_type_name", lupb_fielddef_setcontainingtypename},
-  {"set_default", lupb_fielddef_setdefault},
-  {"set_is_extension", lupb_fielddef_setisextension},
-  {"set_label", lupb_fielddef_setlabel},
-  {"set_lazy", lupb_fielddef_setlazy},
-  {"set_name", lupb_fielddef_setname},
-  {"set_number", lupb_fielddef_setnumber},
-  {"set_packed", lupb_fielddef_setpacked},
-  {"set_subdef", lupb_fielddef_setsubdef},
-  {"set_subdef_name", lupb_fielddef_setsubdefname},
-  {"set_type", lupb_fielddef_settype},
-  {"set_intfmt", lupb_fielddef_setintfmt},
-  {"set_tagdelim", lupb_fielddef_settagdelim},
-
-  {NULL, NULL}
-};
-
-
-/* lupb_oneofdef **************************************************************/
-
-void lupb_oneofdef_pushwrapper(lua_State *L, const upb_oneofdef *o,
-                               const void *ref_donor) {
-  lupb_refcounted_pushwrapper(L, upb_oneofdef_upcast(o), LUPB_ONEOFDEF,
-                              ref_donor, sizeof(void *));
-}
-
-const upb_oneofdef *lupb_oneofdef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_ONEOFDEF);
-}
-
-static upb_oneofdef *lupb_oneofdef_checkmutable(lua_State *L, int narg) {
-  const upb_oneofdef *o = lupb_oneofdef_check(L, narg);
-  if (upb_oneofdef_isfrozen(o))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_oneofdef*)o;
-}
-
-static int lupb_oneofdef_new(lua_State *L) {
-  upb_oneofdef *o = upb_oneofdef_new(&o);
-  lupb_refcounted_pushnewrapper(L, upb_oneofdef_upcast(o), LUPB_ONEOFDEF, &o);
-  return 1;
-}
-
-/* Getters */
-
-static int lupb_oneofdef_containingtype(lua_State *L) {
-  const upb_oneofdef *o = lupb_oneofdef_check(L, 1);
-  lupb_def_pushwrapper(L, upb_msgdef_upcast(upb_oneofdef_containingtype(o)),
-                       NULL);
-  return 1;
-}
-
-static int lupb_oneofdef_field(lua_State *L) {
-  const upb_oneofdef *o = lupb_oneofdef_check(L, 1);
-  int type = lua_type(L, 2);
-  const upb_fielddef *f;
-  if (type == LUA_TNUMBER) {
-    f = upb_oneofdef_itof(o, lua_tointeger(L, 2));
-  } else if (type == LUA_TSTRING) {
-    f = upb_oneofdef_ntofz(o, lua_tostring(L, 2));
-  } else {
-    const char *msg = lua_pushfstring(L, "number or string expected, got %s",
-                                      luaL_typename(L, 2));
-    return luaL_argerror(L, 2, msg);
-  }
-
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(f), NULL);
-  return 1;
-}
-
-static int lupb_oneofdef_len(lua_State *L) {
-  const upb_oneofdef *o = lupb_oneofdef_check(L, 1);
-  lua_pushinteger(L, upb_oneofdef_numfields(o));
-  return 1;
-}
-
-static int lupb_oneofdef_name(lua_State *L) {
-  const upb_oneofdef *o = lupb_oneofdef_check(L, 1);
-  lua_pushstring(L, upb_oneofdef_name(o));
-  return 1;
-}
-
-/* Setters */
-
-static int lupb_oneofdef_add(lua_State *L) {
-  upb_oneofdef *o = lupb_oneofdef_checkmutable(L, 1);
-  upb_fielddef *f = lupb_fielddef_checkmutable(L, 2);
-  CHK(upb_oneofdef_addfield(o, f, NULL, &status));
-  return 0;
-}
-
-static int lupb_oneofdef_setname(lua_State *L) {
-  upb_oneofdef *o = lupb_oneofdef_checkmutable(L, 1);
-  CHK(upb_oneofdef_setname(o, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
-static const struct luaL_Reg lupb_oneofdef_m[] = {
-  {"containing_type", lupb_oneofdef_containingtype},
-  {"field", lupb_oneofdef_field},
-  {"name", lupb_oneofdef_name},
-
-  {"add", lupb_oneofdef_add},
-  {"set_name", lupb_oneofdef_setname},
-
-  {NULL, NULL}
-};
-
-static const struct luaL_Reg lupb_oneofdef_mm[] = {
-  {"__len", lupb_oneofdef_len},
-  {NULL, NULL}
-};
-
-
-/* lupb_msgdef ****************************************************************/
-
-typedef struct {
-  const upb_msgdef *md;
-
-  /* These members are initialized lazily the first time a message is created
-   * for this def. */
-  uint16_t *field_offsets;
-  size_t msg_size;
-  size_t hasbits_size;
-  lua_State *L;
-} lupb_msgdef;
-
-static size_t lupb_msgdef_sizeof() {
-  return sizeof(lupb_msgdef);
-}
-
-void lupb_msgdef_pushwrapper(lua_State *L, const upb_msgdef *m,
-                             const void *ref_donor) {
-  lupb_def_pushwrapper(L, upb_msgdef_upcast(m), ref_donor);
-}
-
-const upb_msgdef *lupb_msgdef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_MSGDEF);
-}
-
-lupb_msgdef *lupb_msgdef_check2(lua_State *L, int narg) {
-  return luaL_checkudata(L, narg, LUPB_MSGDEF);
-}
-
-static upb_msgdef *lupb_msgdef_checkmutable(lua_State *L, int narg) {
-  const upb_msgdef *m = lupb_msgdef_check(L, narg);
-  if (upb_msgdef_isfrozen(m))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_msgdef*)m;
-}
-
-static int lupb_msgdef_new(lua_State *L) {
-  upb_msgdef *md = upb_msgdef_new(&md);
-  lupb_def_pushnewrapper(L, upb_msgdef_upcast(md), &md);
-  return 1;
-}
-
-/* Unlike other refcounted types we need a custom __gc so that we free our field
- * offsets. */
-static int lupb_msgdef_gc(lua_State *L) {
-  lupb_msgdef *lmd = luaL_checkudata(L, 1, LUPB_MSGDEF);
-  free(lmd->field_offsets);
-  lupb_refcounted_gc(L);
-  return 0;
-}
-
-static void lupb_msgdef_init(lua_State *L) {
-  lupb_msgdef *lmd = luaL_checkudata(L, -1, LUPB_MSGDEF);
-  lmd->L = L;
-  lmd->field_offsets = NULL;
-}
-
-static int lupb_msgdef_add(lua_State *L) {
-  upb_msgdef *m = lupb_msgdef_checkmutable(L, 1);
-
-  /* Both oneofs and fields can be added. */
-  if (luaL_testudata(L, 2, LUPB_FIELDDEF)) {
-    upb_fielddef *f = lupb_fielddef_checkmutable(L, 2);
-    CHK(upb_msgdef_addfield(m, f, NULL, &status));
-  } else if (luaL_testudata(L, 2, LUPB_ONEOFDEF)) {
-    upb_oneofdef *o = lupb_oneofdef_checkmutable(L, 2);
-    CHK(upb_msgdef_addoneof(m, o, NULL, &status));
-  }
-  return 0;
-}
-
-static int lupb_msgdef_len(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  lua_pushinteger(L, upb_msgdef_numfields(m));
-  return 1;
-}
-
-static int lupb_msgdef_field(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  int type = lua_type(L, 2);
-  const upb_fielddef *f;
-  if (type == LUA_TNUMBER) {
-    f = upb_msgdef_itof(m, lua_tointeger(L, 2));
-  } else if (type == LUA_TSTRING) {
-    f = upb_msgdef_ntofz(m, lua_tostring(L, 2));
-  } else {
-    const char *msg = lua_pushfstring(L, "number or string expected, got %s",
-                                      luaL_typename(L, 2));
-    return luaL_argerror(L, 2, msg);
-  }
-
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(f), NULL);
-  return 1;
-}
-
-static int lupb_msgdef_lookupname(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  const upb_fielddef *f;
-  const upb_oneofdef *o;
-  if (!upb_msgdef_lookupnamez(m, lua_tostring(L, 2), &f, &o)) {
-    lua_pushnil(L);
-  } else if (o) {
-    lupb_oneofdef_pushwrapper(L, o, NULL);
-  } else {
-    lupb_fielddef_pushwrapper(L, f, NULL);
-  }
-  return 1;
-}
-
-static int lupb_msgfielditer_next(lua_State *L) {
-  upb_msg_field_iter *i = lua_touserdata(L, lua_upvalueindex(1));
-  if (upb_msg_field_done(i)) return 0;
-  lupb_def_pushwrapper(L, upb_fielddef_upcast(upb_msg_iter_field(i)), NULL);
-  upb_msg_field_next(i);
-  return 1;
-}
-
-static int lupb_msgdef_fields(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  upb_msg_field_iter *i = lua_newuserdata(L, sizeof(upb_msg_field_iter));
-  upb_msg_field_begin(i, m);
-  /* Need to guarantee that the msgdef outlives the iter. */
-  lua_pushvalue(L, 1);
-  lua_pushcclosure(L, &lupb_msgfielditer_next, 2);
-  return 1;
-}
-
-static int lupb_msgoneofiter_next(lua_State *L) {
-  upb_msg_oneof_iter *i = lua_touserdata(L, lua_upvalueindex(1));
-  if (upb_msg_oneof_done(i)) return 0;
-  lupb_oneofdef_pushwrapper(L, upb_msg_iter_oneof(i), NULL);
-  upb_msg_oneof_next(i);
-  return 1;
-}
-
-static int lupb_msgdef_oneofs(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  upb_msg_oneof_iter *i = lua_newuserdata(L, sizeof(upb_msg_oneof_iter));
-  upb_msg_oneof_begin(i, m);
-  /* Need to guarantee that the msgdef outlives the iter. */
-  lua_pushvalue(L, 1);
-  lua_pushcclosure(L, &lupb_msgoneofiter_next, 2);
-  return 1;
-}
-
-static int lupb_msgdef_mapentry(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  lua_pushboolean(L, upb_msgdef_mapentry(m));
-  return 1;
-}
-
-static int lupb_msgdef_syntax(lua_State *L) {
-  const upb_msgdef *m = lupb_msgdef_check(L, 1);
-  lua_pushinteger(L, upb_msgdef_syntax(m));
-  return 1;
-}
-
-static const struct luaL_Reg lupb_msgdef_mm[] = {
-  {"__gc", lupb_msgdef_gc},
-  {"__len", lupb_msgdef_len},
-  {NULL, NULL}
-};
-
-static const struct luaL_Reg lupb_msgdef_m[] = {
-  LUPB_COMMON_DEF_METHODS
-  {"add", lupb_msgdef_add},
-  {"field", lupb_msgdef_field},
-  {"fields", lupb_msgdef_fields},
-  {"lookup_name", lupb_msgdef_lookupname},
-  {"oneofs", lupb_msgdef_oneofs},
-  {"syntax", lupb_msgdef_syntax},
-  {"_map_entry", lupb_msgdef_mapentry},
-
-  {NULL, NULL}
-};
-
-
-/* lupb_enumdef ***************************************************************/
-
-const upb_enumdef *lupb_enumdef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_ENUMDEF);
-}
-
-static upb_enumdef *lupb_enumdef_checkmutable(lua_State *L, int narg) {
-  const upb_enumdef *f = lupb_enumdef_check(L, narg);
-  if (upb_enumdef_isfrozen(f))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_enumdef*)f;
-}
-
-static int lupb_enumdef_new(lua_State *L) {
-  upb_enumdef *e = upb_enumdef_new(&e);
-  lupb_def_pushnewrapper(L, upb_enumdef_upcast(e), &e);
-  return 1;
-}
-
-static int lupb_enumdef_add(lua_State *L) {
-  upb_enumdef *e = lupb_enumdef_checkmutable(L, 1);
-  const char *name = lupb_checkname(L, 2);
-  int32_t val = lupb_checkint32(L, 3);
-  CHK(upb_enumdef_addval(e, name, val, &status));
-  return 0;
-}
-
-static int lupb_enumdef_len(lua_State *L) {
-  const upb_enumdef *e = lupb_enumdef_check(L, 1);
-  lua_pushinteger(L, upb_enumdef_numvals(e));
-  return 1;
-}
-
-static int lupb_enumdef_value(lua_State *L) {
-  const upb_enumdef *e = lupb_enumdef_check(L, 1);
-  int type = lua_type(L, 2);
-  if (type == LUA_TNUMBER) {
-    /* Pushes "nil" for a NULL pointer. */
-    int32_t key = lupb_checkint32(L, 2);
-    lua_pushstring(L, upb_enumdef_iton(e, key));
-  } else if (type == LUA_TSTRING) {
-    const char *key = lua_tostring(L, 2);
-    int32_t num;
-    if (upb_enumdef_ntoiz(e, key, &num)) {
-      lua_pushinteger(L, num);
-    } else {
-      lua_pushnil(L);
-    }
-  } else {
-    const char *msg = lua_pushfstring(L, "number or string expected, got %s",
-                                      luaL_typename(L, 2));
-    return luaL_argerror(L, 2, msg);
-  }
-  return 1;
-}
-
-static int lupb_enumiter_next(lua_State *L) {
-  upb_enum_iter *i = lua_touserdata(L, lua_upvalueindex(1));
-  if (upb_enum_done(i)) return 0;
-  lua_pushstring(L, upb_enum_iter_name(i));
-  lua_pushinteger(L, upb_enum_iter_number(i));
-  upb_enum_next(i);
-  return 2;
-}
-
-static int lupb_enumdef_values(lua_State *L) {
-  const upb_enumdef *e = lupb_enumdef_check(L, 1);
-  upb_enum_iter *i = lua_newuserdata(L, sizeof(upb_enum_iter));
-  upb_enum_begin(i, e);
-  /* Need to guarantee that the enumdef outlives the iter. */
-  lua_pushvalue(L, 1);
-  lua_pushcclosure(L, &lupb_enumiter_next, 2);
-  return 1;
-}
-
-static const struct luaL_Reg lupb_enumdef_mm[] = {
-  {"__len", lupb_enumdef_len},
-  {NULL, NULL}
-};
-
-static const struct luaL_Reg lupb_enumdef_m[] = {
-  LUPB_COMMON_DEF_METHODS
-  {"add", lupb_enumdef_add},
-  {"value", lupb_enumdef_value},
-  {"values", lupb_enumdef_values},
-  {NULL, NULL}
-};
-
-
-/* lupb_filedef ***************************************************************/
-
-void lupb_filedef_pushwrapper(lua_State *L, const upb_filedef *f,
-                              const void *ref_donor) {
-  lupb_refcounted_pushwrapper(L, upb_filedef_upcast(f), LUPB_FILEDEF, ref_donor,
-                              sizeof(void *));
-}
-
-void lupb_filedef_pushnewrapper(lua_State *L, const upb_filedef *f,
-                                const void *ref_donor) {
-  lupb_refcounted_pushnewrapper(L, upb_filedef_upcast(f), LUPB_FILEDEF,
-                                ref_donor);
-}
-
-const upb_filedef *lupb_filedef_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_FILEDEF);
-}
-
-static upb_filedef *lupb_filedef_checkmutable(lua_State *L, int narg) {
-  const upb_filedef *f = lupb_filedef_check(L, narg);
-  if (upb_filedef_isfrozen(f))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_filedef*)f;
-}
-
-static int lupb_filedef_new(lua_State *L) {
-  upb_filedef *f = upb_filedef_new(&f);
-  lupb_filedef_pushnewrapper(L, f, &f);
-  return 1;
-}
-
-static int lupb_filedef_def(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, 1);
-  int index = luaL_checkint(L, 2);
-  const upb_def *def = upb_filedef_def(f, index);
-
-  if (!def) {
-    return luaL_error(L, "index out of range");
-  }
-
-  lupb_def_pushwrapper(L, def, NULL);
-  return 1;
-}
-
-static int lupb_filedef_name(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, 1);
-  lua_pushstring(L, upb_filedef_name(f));
-  return 1;
-}
-
-static int lupb_filedef_package(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, 1);
-  lua_pushstring(L, upb_filedef_package(f));
-  return 1;
-}
-
-static int lupb_filedef_len(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, 1);
-  lua_pushinteger(L, upb_filedef_defcount(f));
-  return 1;
-}
-
-static int lupb_filedef_setname(lua_State *L) {
-  upb_filedef *f = lupb_filedef_checkmutable(L, 1);
-  CHK(upb_filedef_setname(f, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
-static int lupb_filedef_setpackage(lua_State *L) {
-  upb_filedef *f = lupb_filedef_checkmutable(L, 1);
-  CHK(upb_filedef_setpackage(f, lupb_checkname(L, 2), &status));
-  return 0;
-}
-
-static int lupb_filedefiter_next(lua_State *L) {
-  const upb_filedef *f = lupb_filedef_check(L, lua_upvalueindex(1));
-  int type = lua_tointeger(L, lua_upvalueindex(2));
-  size_t i = lua_tointeger(L, lua_upvalueindex(3));
-  size_t n = upb_filedef_defcount(f);
-
-  for (; i < n; i++) {
-    const upb_def *def;
-
-    def = upb_filedef_def(f, i);
-    UPB_ASSERT(def);
-
-    if (type == UPB_DEF_ANY || upb_def_type(def) == type) {
-      lua_pushinteger(L, i + 1);
-      lua_replace(L, lua_upvalueindex(3));
-      lupb_def_pushwrapper(L, def, NULL);
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-static int lupb_filedef_defs(lua_State *L) {
-  lupb_filedef_check(L, 1);
-  luaL_checkinteger(L, 2);   /* Def type.  Could make this optional. */
-  lua_pushnumber(L, 0);      /* Index, starts at zero. */
-  lua_pushcclosure(L, &lupb_filedefiter_next, 3);
-  return 1;
-}
-
-static const struct luaL_Reg lupb_filedef_mm[] = {
-  {"__len", lupb_filedef_len},
-  {NULL, NULL}
-};
-
-static const struct luaL_Reg lupb_filedef_m[] = {
-  {"def", lupb_filedef_def},
-  {"defs", lupb_filedef_defs},
-  {"name", lupb_filedef_name},
-  {"package", lupb_filedef_package},
-
-  {"set_name", lupb_filedef_setname},
-  {"set_package", lupb_filedef_setpackage},
-
-  {NULL, NULL}
-};
-
-/* lupb_symtab ****************************************************************/
-
-/* Inherits a ref on the symtab.
- * Checks that narg is a proper lupb_symtab object.  If it is, leaves its
- * metatable on the stack for cache lookups/updates. */
-const upb_symtab *lupb_symtab_check(lua_State *L, int narg) {
-  return lupb_refcounted_check(L, narg, LUPB_SYMTAB);
-}
-
-static upb_symtab *lupb_symtab_checkmutable(lua_State *L, int narg) {
-  const upb_symtab *s = lupb_symtab_check(L, narg);
-  if (upb_symtab_isfrozen(s))
-    luaL_error(L, "not allowed on frozen value");
-  return (upb_symtab*)s;
-}
-
-void lupb_symtab_pushwrapper(lua_State *L, const upb_symtab *s,
-                             const void *ref_donor) {
-  lupb_refcounted_pushwrapper(L, upb_symtab_upcast(s), LUPB_SYMTAB, ref_donor,
-                              sizeof(void *));
-}
-
-void lupb_symtab_pushnewrapper(lua_State *L, const upb_symtab *s,
-                               const void *ref_donor) {
-  lupb_refcounted_pushnewrapper(L, upb_symtab_upcast(s), LUPB_SYMTAB,
-                                ref_donor);
-}
-
-static int lupb_symtab_new(lua_State *L) {
-  upb_symtab *s = upb_symtab_new(&s);
-  lupb_symtab_pushnewrapper(L, s, &s);
-  return 1;
-}
-
-static int lupb_symtab_freeze(lua_State *L) {
-  upb_symtab_freeze(lupb_symtab_checkmutable(L, 1));
-  return 0;
-}
-
-static int lupb_symtab_isfrozen(lua_State *L) {
-  lua_pushboolean(L, upb_symtab_isfrozen(lupb_symtab_check(L, 1)));
-  return 1;
-}
-
-static int lupb_symtab_add(lua_State *L) {
-  upb_symtab *s = lupb_symtab_checkmutable(L, 1);
-  int n;
-  upb_def **defs;
-
-  luaL_checktype(L, 2, LUA_TTABLE);
-  /* Iterate over table twice.  First iteration to count entries and
-   * check constraints. */
-  n = 0;
-  for (lua_pushnil(L); lua_next(L, 2); lua_pop(L, 1)) {
-    lupb_def_checkmutable(L, -1);
-    ++n;
-  }
-
-  /* Second iteration to build deflist.
-   * Allocate list with lua_newuserdata() so it is anchored as a GC root in
-   * case any Lua functions longjmp(). */
-  defs = lua_newuserdata(L, n * sizeof(*defs));
-  n = 0;
-  for (lua_pushnil(L); lua_next(L, 2); lua_pop(L, 1)) {
-    upb_def *def = lupb_def_checkmutable(L, -1);
-    defs[n++] = def;
-  }
-
-  CHK(upb_symtab_add(s, defs, n, NULL, &status));
-  return 0;
-}
-
-static int lupb_symtab_addfile(lua_State *L) {
-  upb_symtab *s = lupb_symtab_checkmutable(L, 1);
-  upb_filedef *f = lupb_filedef_checkmutable(L, 2);
-  CHK(upb_symtab_addfile(s, f, &status));
-  return 0;
-}
-
-static int lupb_symtab_lookup(lua_State *L) {
-  const upb_symtab *s = lupb_symtab_check(L, 1);
-  int i;
-  for (i = 2; i <= lua_gettop(L); i++) {
-    const upb_def *def = upb_symtab_lookup(s, luaL_checkstring(L, i));
-    lupb_def_pushwrapper(L, def, NULL);
-    lua_replace(L, i);
-  }
-  return lua_gettop(L) - 1;
-}
-
-static int lupb_symtabiter_next(lua_State *L) {
-  upb_symtab_iter *i = lua_touserdata(L, lua_upvalueindex(1));
-  if (upb_symtab_done(i)) return 0;
-  lupb_def_pushwrapper(L, upb_symtab_iter_def(i), NULL);
-  upb_symtab_next(i);
-  return 1;
-}
-
-static int lupb_symtab_defs(lua_State *L) {
-  const upb_symtab *s = lupb_symtab_check(L, 1);
-  upb_deftype_t type = lua_gettop(L) > 1 ? luaL_checkint(L, 2) : UPB_DEF_ANY;
-  upb_symtab_iter *i = lua_newuserdata(L, sizeof(upb_symtab_iter));
-  upb_symtab_begin(i, s, type);
-  /* Need to guarantee that the symtab outlives the iter. */
-  lua_pushvalue(L, 1);
-  lua_pushcclosure(L, &lupb_symtabiter_next, 2);
-  return 1;
-}
-
-static const struct luaL_Reg lupb_symtab_m[] = {
-  {"add", lupb_symtab_add},
-  {"add_file", lupb_symtab_addfile},
-  {"defs", lupb_symtab_defs},
-  {"freeze", lupb_symtab_freeze},
-  {"is_frozen", lupb_symtab_isfrozen},
-  {"lookup", lupb_symtab_lookup},
-  {NULL, NULL}
-};
-
-
-/* lupb_array *****************************************************************/
-
-/* A lupb_array provides a strongly-typed array.
- *
- * For the moment we store all values in the userdata's environment table /
- * userval, for simplicity.  Later we may wish to move the data into raw
- * memory as both a space and time optimization
- *
- * Compared to regular Lua tables:
- *
- * - we only allow integer indices.
- * - all entries must match the type of the table.
- * - we do not allow "holes" in the array; you can only assign to an existing
- *   index or one past the end (which will grow the array by one). */
-
-typedef struct {
-  uint32_t size;
-  upb_fieldtype_t type;
-  const upb_msgdef *msgdef;  /* Only when type == UPB_TYPE_MESSAGE */
-} lupb_array;
-
-static lupb_array *lupb_array_check(lua_State *L, int narg) {
-  return luaL_checkudata(L, narg, LUPB_ARRAY);
-}
-
-static uint32_t lupb_array_checkindex(lua_State *L, int narg, uint32_t max) {
-  uint32_t n = lupb_checkuint32(L, narg);
-  if (n == 0 || n > max) {  /* Lua uses 1-based indexing. :( */
-    luaL_error(L, "Invalid array index.");
-  }
-  return n;
-}
-
-static int lupb_array_new(lua_State *L) {
-  lupb_array *array = newudata_with_userval(L, sizeof(*array), LUPB_ARRAY);
-  array->size = 0;
-
-  if (lua_type(L, 1) == LUA_TNUMBER) {
-    array->type = lupb_checkfieldtype(L, 1);
-    if (array->type == UPB_TYPE_MESSAGE) {
-      return luaL_error(
-          L, "For message arrays construct with the specific message type.");
-    }
-  } else {
-    array->type = UPB_TYPE_MESSAGE;
-    array->msgdef = lupb_msgdef_check(L, 1);
-
-    /* Store a reference to this msgdef in the environment table to ensure it
-     * outlives this array. */
-    lua_getuservalue(L, -1);
-    lua_pushvalue(L, 1);
-    lua_rawseti(L, -2, 0);
-    lua_pop(L, 1);  /* Pop userval. */
-  }
-
-  return 1;
-}
-
-static int lupb_array_newindex(lua_State *L) {
-  lupb_array *array = lupb_array_check(L, 1);
-  uint32_t n = lupb_array_checkindex(L, 2, array->size + 1);
-
-  if (n == array->size + 1) {
-    array->size++;
-  }
-
-  if (array->type == UPB_TYPE_MESSAGE) {
-    if (array->msgdef != lupb_msg_checkdef(L, 3)) {
-      return luaL_error(L, "Tried to assign wrong message type.");
-    }
-  } else {
-    lupb_checkval(L, 3, array->type);
-  }
-
-  /* Write value to userval table. */
-  lua_getuservalue(L, 1);
-  lua_pushvalue(L, 3);
-  lua_rawseti(L, -2, n);
-
-  return 0;  /* 1 for chained assignments? */
-}
-
-static int lupb_array_index(lua_State *L) {
-  lupb_array *array = lupb_array_check(L, 1);
-  uint32_t n = lupb_array_checkindex(L, 2, array->size);
-
-  lua_getuservalue(L, 1);
-  lua_rawgeti(L, -1, n);
-  return 1;
-}
-
-static int lupb_array_len(lua_State *L) {
-  lupb_array *array = lupb_array_check(L, 1);
-  lua_pushnumber(L, array->size);
-  return 1;
-}
-
-static const struct luaL_Reg lupb_array_mm[] = {
-  {"__index", lupb_array_index},
-  {"__len", lupb_array_len},
-  {"__newindex", lupb_array_newindex},
-  {NULL, NULL}
-};
-
-/* lupb_msg **************************************************************/
-
-/* A lupb_msg is a userdata where:
- *
- * - the userdata's memory contains hasbits and primitive fields.
- * - the userdata's environment table / uservalue contains references to string
- *   fields, submessage fields, and array fields. */
-
-typedef struct {
-  const lupb_msgdef *lmd;
-  /* Data follows, in a flat buffer. */
-} lupb_msg;
-
-#define MSGDEF_INDEX 0
-
-static bool in_userval(const upb_fielddef *f) {
-  return upb_fielddef_isseq(f) || upb_fielddef_issubmsg(f) ||
-         upb_fielddef_isstring(f);
-}
-
-static size_t lupb_sizeof(lua_State *L, const upb_fielddef *f) {
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_BOOL:
-      return 1;
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_ENUM:
-    case UPB_TYPE_FLOAT:
-      return 4;
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT64:
-    case UPB_TYPE_DOUBLE:
-      return 8;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-    case UPB_TYPE_MESSAGE:
-      break;
-  }
-  lupb_assert(L, false);
-  return 0;
-}
-
-static int div_round_up(size_t n, size_t d) {
-  int ret = n / d;
-  /* If there was a positive remainder, then the result was rounded down and we
-   * need to compensate by adding one. */
-  if (n % d > 0) ++ret;
-  return ret;
-}
-
-static size_t align_up(size_t val, size_t align) {
-  return val % align == 0 ? val : val + align - (val % align);
-}
-
-/* If we always read/write as a consistent type to each value, this shouldn't
- * violate aliasing.
- *
- * Note that the slightly prettier option of:
- *
- *   *(type*)(&msg->data[ofs])
- *
- * ...is potentially more questionable wrt the C standard and aliasing.
- * Does the expression &msg->data[ofs] "access the stored value"?  If so,
- * this would violate aliasing.  So instead we use the expression:
- *
- *   (char*)msg + sizeof(lupb_msg) + ofs
- *
- * ...which unambigiously is doing nothing but calculating a pointer address. */
-#define CHARPTR_AT(msg, ofs) ((char*)msg + sizeof(lupb_msg) + ofs)
-#define DEREF(msg, ofs, type) *(type*)CHARPTR_AT(msg, ofs)
-
-lupb_msg *lupb_msg_check(lua_State *L, int narg) {
-  lupb_msg *msg = luaL_checkudata(L, narg, LUPB_MSG);
-  if (!msg->lmd) luaL_error(L, "called into dead msg");
-  return msg;
-}
-
-const upb_msgdef *lupb_msg_checkdef(lua_State *L, int narg) {
-  return lupb_msg_check(L, narg)->lmd->md;
-}
-
-static const upb_fielddef *lupb_msg_checkfield(lua_State *L,
-                                               const lupb_msgdef *lmd,
-                                               int fieldarg) {
-  size_t len;
-  const char *fieldname = luaL_checklstring(L, fieldarg, &len);
-  const upb_fielddef *f = upb_msgdef_ntof(lmd->md, fieldname, len);
-
-  if (!f) {
-    const char *msg = lua_pushfstring(L, "no such field: %s", fieldname);
-    luaL_argerror(L, fieldarg, msg);
-    return NULL;  /* Never reached. */
-  }
-
-  return f;
-}
-
-/* Assigns offsets for storing data in instances of messages for this type, if
- * they have not already been assigned.  "narg" should be the stack location of
- * a Lua msgdef object.  It should be frozen (if it is not, we will throw an
- * error).  It should not throw errors in any other case, since we may have
- * values on our stack that would leak if we longjmp'd across them.
- *
- * TODO(haberman): (if we want to avoid this and be robust against even lua
- * errors due to OOM, we should stop using upb_handlers_newfrozen() and
- * implement it ourselves with a Lua table as cache, since that would get
- * cleaned up properly on error). */
-static lupb_msgdef *lupb_msg_assignoffsets(lua_State *L, int narg) {
-  int idx;
-  upb_msg_field_iter i;
-  lupb_msgdef *lmd = lupb_msgdef_check2(L, narg);
-
-  if (!upb_msgdef_isfrozen(lmd->md))
-    luaL_error(L, "msgdef must be frozen");
-
-  if (lmd->field_offsets) {
-    /* Already assigned. */
-    return lmd;
-  }
-
-  {
-    int n = upb_msgdef_numfields(lmd->md);
-    uint16_t *offsets = malloc(sizeof(*offsets) * n);
-
-    /* Offset with the raw data part; starts with hasbits. */
-    size_t hasbits_size = div_round_up(n, 8);
-    size_t data_ofs = hasbits_size;
-    /* Index within the userval.
-     * Starts at one to not collide with MSGDEF_INDEX. */
-    size_t userval_idx = 1;
-
-    /* Assign offsets. */
-    for (upb_msg_field_begin(&i, lmd->md);
-         !upb_msg_field_done(&i);
-         upb_msg_field_next(&i)) {
-      upb_fielddef *f = upb_msg_iter_field(&i);
-      if (in_userval(f)) {
-        offsets[upb_fielddef_index(f)] = userval_idx++;
-      } else {
-        size_t size = lupb_sizeof(L, f);
-        data_ofs = align_up(data_ofs, size);
-        offsets[upb_fielddef_index(f)] = data_ofs;
-        data_ofs += size;
-      }
-    }
-
-    lmd->field_offsets = offsets;
-    lmd->msg_size = sizeof(lupb_msg) + data_ofs;
-    lmd->hasbits_size = hasbits_size;
-  }
-
-  /* Now recursively assign offsets for all submessages, and also add them to
-   * the uservalue to ensure that all the lupb_msgdef objects for our
-   * submessages outlive us.  This is particularly important if/when we build
-   * handlers to populate this msgdef. */
-
-  lua_pushvalue(L, narg);
-  lua_newtable(L);  /* This will be our userval. */
-
-  idx = 1;
-  for (upb_msg_field_begin(&i, lmd->md);
-       !upb_msg_field_done(&i);
-       upb_msg_field_next(&i)) {
-    upb_fielddef *f = upb_msg_iter_field(&i);
-    if (upb_fielddef_type(f) == UPB_TYPE_MESSAGE) {
-      bool created = lupb_def_pushwrapper(L, upb_fielddef_subdef(f), NULL);
-      UPB_ASSERT(!created);
-      lupb_msg_assignoffsets(L, -1);
-      lua_rawseti(L, -2, idx++);  /* Append to uservalue. */
-    }
-  }
-
-  lua_setuservalue(L, -2);
-  lua_pop(L, 1);  /* copy of msgdef */
-
-  return lmd;
-}
-
-void lupb_msg_pushnew(lua_State *L, int narg) {
-  lupb_msgdef *lmd = lupb_msg_assignoffsets(L, narg);
-  lupb_msg *msg;
-
-  /* Add passed-in MessageDef to a table which will become the msg's userval. */
-  lua_pushvalue(L, narg);
-  lua_newtable(L);
-  lua_pushvalue(L, narg);
-  lua_rawseti(L, -2, MSGDEF_INDEX);
-
-  msg = newudata_with_userval(L, lmd->msg_size, LUPB_MSG);
-  memset(msg, 0, lmd->msg_size);
-
-  /* Create a msg->msgdef reference, both:
-   * 1. a pointer in the userdata itself (for easy access) and */
-  msg->lmd = lmd;
-
-  /* 2. a reference in Lua-space from the msg's uservalue to the messagedef
-   *    wrapper object (so the msgdef wrapper object will always outlive us,
-   *    GC-wise). */
-  lua_pushvalue(L, -2);     /* Push the table from before. */
-  lua_setuservalue(L, -2);  /* Pop table, now msg is at top again. */
-  lua_remove(L, -2);        /* Remove table, so new message is only new val. */
-}
-
-static int lupb_msg_new(lua_State *L) {
-  lupb_msg_pushnew(L, 1);
-  return 1;
-}
-
-static bool lupb_msg_has(const lupb_msg *msg, const upb_fielddef *f) {
-  uint16_t idx = upb_fielddef_index(f);
-  return *CHARPTR_AT(msg, idx / 8) & (1 << (idx % 8));
-}
-
-static void lupb_msg_set(lupb_msg *msg, const upb_fielddef *f) {
-  uint16_t idx = upb_fielddef_index(f);
-  *CHARPTR_AT(msg, idx / 8) |= (1 << (idx % 8));
-}
-
-static int lupb_msg_index(lua_State *L) {
-  lupb_msg *msg = lupb_msg_check(L, 1);
-  const upb_fielddef *f = lupb_msg_checkfield(L, msg->lmd, 2);
-  int ofs;
-
-  if (!upb_fielddef_isseq(f) && !lupb_msg_has(msg, f)) {
-    lua_pushnil(L);
-    return 1;
-  }
-
-  ofs = msg->lmd->field_offsets[upb_fielddef_index(f)];
-
-  if (in_userval(f)) {
-    lua_getuservalue(L, 1);
-    lua_pushinteger(L, ofs);
-    lua_rawget(L, -2);
-  } else {
-    switch (upb_fielddef_type(f)) {
-      case UPB_TYPE_FLOAT:
-        lupb_pushfloat(L, DEREF(msg, ofs, float));
-        break;
-      case UPB_TYPE_DOUBLE:
-        lupb_pushdouble(L, DEREF(msg, ofs, double));
-        break;
-      case UPB_TYPE_BOOL:
-        lua_pushboolean(L, DEREF(msg, ofs, bool));
-        break;
-      case UPB_TYPE_ENUM:
-      case UPB_TYPE_INT32:
-        lupb_pushint32(L, DEREF(msg, ofs, int32_t));
-        break;
-      case UPB_TYPE_UINT32:
-        lupb_pushuint32(L, DEREF(msg, ofs, uint32_t));
-        break;
-      case UPB_TYPE_INT64:
-        if (LUA_VERSION_NUM < 503) {
-          /* Check value? Lua < 5.3.0 has no native integer support, lua_Number
-           * is probably double which can't exactly represent large int64s. */
-        }
-        lupb_pushint64(L, DEREF(msg, ofs, int64_t));
-        break;
-      case UPB_TYPE_UINT64:
-        if (LUA_VERSION_NUM < 503) {
-          /* Check value? Lua < 5.3.0 has no native integer support, lua_Number
-           * is probably double which can't exactly represent large uint64s. */
-        }
-        lupb_pushuint64(L, DEREF(msg, ofs, uint64_t));
-        break;
-      case UPB_TYPE_STRING:
-      case UPB_TYPE_BYTES:
-      case UPB_TYPE_MESSAGE:
-        lupb_assert(L, false);
-        break;
-    }
-  }
-
-  return 1;
-}
-
-int lupb_msg_newindex(lua_State *L) {
-  lupb_msg *msg = lupb_msg_check(L, 1);
-  const upb_fielddef *f = lupb_msg_checkfield(L, msg->lmd, 2);
-  int ofs;
-
-  lupb_msg_set(msg, f);
-
-  ofs = msg->lmd->field_offsets[upb_fielddef_index(f)];
-
-  if (in_userval(f)) {
-    /* Type-check and then store in the userval. */
-    if (upb_fielddef_isseq(f)) {
-      lupb_array *array = lupb_array_check(L, 3);
-      if (array->type != upb_fielddef_type(f) ||
-          (array->type == UPB_TYPE_MESSAGE &&
-           array->msgdef != upb_fielddef_msgsubdef(f))) {
-        return luaL_error(L, "Array type mismatch");
-      }
-    } else if (upb_fielddef_isstring(f)) {
-      lupb_checkstring(L, 3);
-    } else {
-      if (lupb_msg_checkdef(L, 3) != upb_fielddef_msgsubdef(f)) {
-        return luaL_error(L, "Message type mismatch");
-      }
-    }
-    lua_getuservalue(L, 1);
-    lua_pushvalue(L, 3);
-    lua_rawseti(L, -2, ofs);
-  } else {
-    switch (upb_fielddef_type(f)) {
-      case UPB_TYPE_FLOAT:
-        DEREF(msg, ofs, float) = lupb_checkfloat(L, 3);
-        break;
-      case UPB_TYPE_DOUBLE:
-        DEREF(msg, ofs, double) = lupb_checkdouble(L, 3);
-        break;
-      case UPB_TYPE_ENUM:
-      case UPB_TYPE_INT32:
-        DEREF(msg, ofs, int32_t) = lupb_checkint32(L, 3);
-        break;
-      case UPB_TYPE_UINT32:
-        DEREF(msg, ofs, uint32_t) = lupb_checkuint32(L, 3);
-        break;
-      case UPB_TYPE_INT64:
-        DEREF(msg, ofs, int64_t) = lupb_checkint64(L, 3);
-        break;
-      case UPB_TYPE_UINT64:
-        DEREF(msg, ofs, uint64_t) = lupb_checkuint64(L, 3);
-        break;
-      case UPB_TYPE_BOOL:
-        DEREF(msg, ofs, bool) = lupb_checkbool(L, 3);
-        break;
-      case UPB_TYPE_STRING:
-      case UPB_TYPE_BYTES:
-      case UPB_TYPE_MESSAGE:
-        lupb_assert(L, false);
-    }
-  }
-
-  return 0;  /* 1 for chained assignments? */
-}
-
-static const struct luaL_Reg lupb_msg_mm[] = {
-  {"__index", lupb_msg_index},
-  {"__newindex", lupb_msg_newindex},
-  {NULL, NULL}
-};
-
-
-/* lupb_msg populating handlers ***********************************************/
-
-/* NOTE: doesn't support repeated or submessage fields yet.  Coming soon. */
-
-typedef struct {
-  uint32_t ofs;
-  uint32_t hasbit;
-} lupb_handlerdata;
-
-static void lupb_sethasbit(lupb_msg *msg, uint32_t hasbit) {
-  *CHARPTR_AT(msg, hasbit / 8) |= 1 << (hasbit % 8);
-}
-
-static size_t strhandler(void *closure, const void *hd, const char *str,
-                         size_t len, const upb_bufhandle *handle) {
-  lupb_msg *msg = closure;
-  const lupb_handlerdata *data = hd;
-  lua_State *L = msg->lmd->L;
-  UPB_UNUSED(handle);
-
-  lua_pushlstring(L, str, len);
-  lua_rawseti(L, -2, data->ofs);
-  lupb_sethasbit(msg, data->hasbit);
-  return len;
-}
-
-const void *newhandlerdata(upb_handlers *h, uint32_t ofs, uint32_t hasbit) {
-  lupb_handlerdata *data = malloc(sizeof(*data));
-  data->ofs = ofs;
-  data->hasbit = hasbit;
-  upb_handlers_addcleanup(h, data, free);
-  return data;
-}
-
-void callback(const void *closure, upb_handlers *h) {
-  lua_State *L = (lua_State*)closure;
-  lupb_msgdef *lmd;
-  upb_msg_field_iter i;
-
-  lupb_def_pushwrapper(L, upb_msgdef_upcast(upb_handlers_msgdef(h)), NULL);
-  lmd = lupb_msg_assignoffsets(L, -1);
-  upb_msg_field_begin(&i, upb_handlers_msgdef(h));
-  for (; !upb_msg_field_done(&i); upb_msg_field_next(&i)) {
-    upb_fielddef *f = upb_msg_iter_field(&i);
-    int hasbit = upb_fielddef_index(f);
-    uint16_t ofs = lmd->field_offsets[upb_fielddef_index(f)];
-    if (upb_fielddef_isseq(f)) {
-      luaL_error(L, "Doesn't support repeated fields yet.");
-    } else {
-      switch (upb_fielddef_type(f)) {
-        case UPB_TYPE_BOOL:
-        case UPB_TYPE_INT32:
-        case UPB_TYPE_UINT32:
-        case UPB_TYPE_ENUM:
-        case UPB_TYPE_FLOAT:
-        case UPB_TYPE_INT64:
-        case UPB_TYPE_UINT64:
-        case UPB_TYPE_DOUBLE:
-          hasbit += sizeof(lupb_msg) * 8;
-          ofs += sizeof(lupb_msg);
-          upb_shim_set(h, f, ofs, hasbit);
-          break;
-        case UPB_TYPE_STRING:
-        case UPB_TYPE_BYTES: {
-          upb_handlerattr attr = UPB_HANDLERATTR_INITIALIZER;
-          upb_handlerattr_sethandlerdata(&attr, newhandlerdata(h, ofs, hasbit));
-          /* XXX: does't currently handle split buffers. */
-          upb_handlers_setstring(h, f, strhandler, &attr);
-          upb_handlerattr_uninit(&attr);
-          break;
-        }
-        case UPB_TYPE_MESSAGE:
-          luaL_error(L, "Doesn't support submessages yet.");
-          break;
-      }
-    }
-  }
-  lua_pop(L, 1);  /* msgdef wrapper */
-}
-
-const upb_handlers *lupb_msg_newwritehandlers(lua_State *L, int narg,
-                                              const void *owner) {
-  lupb_msgdef *lmd = lupb_msg_assignoffsets(L, narg);
-  return upb_handlers_newfrozen(lmd->md, owner, callback, L);
-}
-
-
-/* lupb toplevel **************************************************************/
-
-static int lupb_freeze(lua_State *L) {
-  int n = lua_gettop(L);
-  int i;
-  /* Scratch memory; lua_newuserdata() anchors it as a GC root in case any Lua
-   * functions fail. */
-  upb_def **defs = lua_newuserdata(L, n * sizeof(upb_def*));
-
-  for (i = 0; i < n; i++) {
-    /* Could allow an array of defs here also. */
-    defs[i] = lupb_def_checkmutable(L, i + 1);
-  }
-  CHK(upb_def_freeze(defs, n, &status));
-  return 0;
-}
-
-/* This is a *temporary* API that will be removed once pending refactorings are
- * complete (it does not belong here in core because it depends on both
- * the descriptor.proto schema and the protobuf binary format. */
-static int lupb_loaddescriptor(lua_State *L) {
-  size_t len;
-  const char *str = luaL_checklstring(L, 1, &len);
-  size_t i;
-  upb_filedef **files = NULL;
-  CHK(files = upb_loaddescriptor(str, len, &files, &status));
-
-  lua_newtable(L);
-  for (i = 1; *files; i++, files++) {
-    lupb_filedef_pushnewrapper(L, *files, &files);
-    lua_rawseti(L, -2, i);
-  }
-
-  return 1;
-}
 
 static const struct luaL_Reg lupb_toplevel_m[] = {
-  {"Array", lupb_array_new},
-  {"EnumDef", lupb_enumdef_new},
-  {"FieldDef", lupb_fielddef_new},
-  {"FileDef", lupb_filedef_new},
-  {"Message", lupb_msg_new},
-  {"MessageDef", lupb_msgdef_new},
-  {"OneofDef", lupb_oneofdef_new},
-  {"SymbolTable", lupb_symtab_new},
-  {"freeze", lupb_freeze},
-  {"load_descriptor", lupb_loaddescriptor},
-
   {NULL, NULL}
 };
 
 void lupb_register_type(lua_State *L, const char *name, const luaL_Reg *m,
-                        const luaL_Reg *mm, bool refcount_gc) {
+                        const luaL_Reg *mm) {
   luaL_newmetatable(L, name);
 
   if (mm) {
     lupb_setfuncs(L, mm);
   }
 
-  if (refcount_gc) {
-    lupb_setfuncs(L, lupb_refcounted_mm);
-  }
-
   if (m) {
     /* Methods go in the mt's __index method.  This implies that you can'
      * implement __index and also have methods. */
@@ -2083,102 +232,14 @@ void lupb_register_type(lua_State *L, const char *name, const luaL_Reg *m,
   lua_pop(L, 1);  /* The mt. */
 }
 
-static void lupb_setfieldi(lua_State *L, const char *field, int i) {
-  lua_pushinteger(L, i);
-  lua_setfield(L, -2, field);
-}
-
 int luaopen_upb_c(lua_State *L) {
   static char module_key;
   if (lupb_openlib(L, &module_key, "upb_c", lupb_toplevel_m)) {
     return 1;
   }
 
-  /* Non-refcounted types. */
-  lupb_register_type(L, LUPB_ARRAY,    NULL,            lupb_array_mm,   false);
-  lupb_register_type(L, LUPB_MSG,      NULL,            lupb_msg_mm,     false);
-
-  /* Refcounted types. */
-  lupb_register_type(L, LUPB_ENUMDEF,  lupb_enumdef_m,  lupb_enumdef_mm,  true);
-  lupb_register_type(L, LUPB_FIELDDEF, lupb_fielddef_m, NULL,             true);
-  lupb_register_type(L, LUPB_FILEDEF,  lupb_filedef_m,  lupb_filedef_mm,  true);
-  lupb_register_type(L, LUPB_ONEOFDEF, lupb_oneofdef_m, lupb_oneofdef_mm, true);
-  lupb_register_type(L, LUPB_SYMTAB,   lupb_symtab_m,   NULL,             true);
-
-  /* Refcounted but with custom __gc. */
-  lupb_register_type(L, LUPB_MSGDEF,   lupb_msgdef_m,   lupb_msgdef_mm,  false);
-
-  /* Create our object cache. */
-  lua_newtable(L);
-  lua_createtable(L, 0, 1);  /* Cache metatable. */
-  lua_pushstring(L, "v");    /* Values are weak. */
-  lua_setfield(L, -2, "__mode");
-  lua_setmetatable(L, -2);
-  lua_setfield(L, LUA_REGISTRYINDEX, LUPB_OBJCACHE);
-
-  /* Register constants. */
-  lupb_setfieldi(L, "LABEL_OPTIONAL", UPB_LABEL_OPTIONAL);
-  lupb_setfieldi(L, "LABEL_REQUIRED", UPB_LABEL_REQUIRED);
-  lupb_setfieldi(L, "LABEL_REPEATED", UPB_LABEL_REPEATED);
-
-  lupb_setfieldi(L, "TYPE_DOUBLE",    UPB_TYPE_DOUBLE);
-  lupb_setfieldi(L, "TYPE_FLOAT",     UPB_TYPE_FLOAT);
-  lupb_setfieldi(L, "TYPE_INT64",     UPB_TYPE_INT64);
-  lupb_setfieldi(L, "TYPE_UINT64",    UPB_TYPE_UINT64);
-  lupb_setfieldi(L, "TYPE_INT32",     UPB_TYPE_INT32);
-  lupb_setfieldi(L, "TYPE_BOOL",      UPB_TYPE_BOOL);
-  lupb_setfieldi(L, "TYPE_STRING",    UPB_TYPE_STRING);
-  lupb_setfieldi(L, "TYPE_MESSAGE",   UPB_TYPE_MESSAGE);
-  lupb_setfieldi(L, "TYPE_BYTES",     UPB_TYPE_BYTES);
-  lupb_setfieldi(L, "TYPE_UINT32",    UPB_TYPE_UINT32);
-  lupb_setfieldi(L, "TYPE_ENUM",      UPB_TYPE_ENUM);
-
-  lupb_setfieldi(L, "INTFMT_VARIABLE",  UPB_INTFMT_VARIABLE);
-  lupb_setfieldi(L, "INTFMT_FIXED",     UPB_INTFMT_FIXED);
-  lupb_setfieldi(L, "INTFMT_ZIGZAG",    UPB_INTFMT_ZIGZAG);
-
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_DOUBLE",    UPB_DESCRIPTOR_TYPE_DOUBLE);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_FLOAT",     UPB_DESCRIPTOR_TYPE_FLOAT);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_INT64",     UPB_DESCRIPTOR_TYPE_INT64);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_UINT64",    UPB_DESCRIPTOR_TYPE_UINT64);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_INT32",     UPB_DESCRIPTOR_TYPE_INT32);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_FIXED64",   UPB_DESCRIPTOR_TYPE_FIXED64);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_FIXED32",   UPB_DESCRIPTOR_TYPE_FIXED32);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_BOOL",      UPB_DESCRIPTOR_TYPE_BOOL);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_STRING",    UPB_DESCRIPTOR_TYPE_STRING);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_GROUP",     UPB_DESCRIPTOR_TYPE_GROUP);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_MESSAGE",   UPB_DESCRIPTOR_TYPE_MESSAGE);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_BYTES",     UPB_DESCRIPTOR_TYPE_BYTES);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_UINT32",    UPB_DESCRIPTOR_TYPE_UINT32);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_ENUM",      UPB_DESCRIPTOR_TYPE_ENUM);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_SFIXED32",  UPB_DESCRIPTOR_TYPE_SFIXED32);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_SFIXED64",  UPB_DESCRIPTOR_TYPE_SFIXED64);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT32",    UPB_DESCRIPTOR_TYPE_SINT32);
-  lupb_setfieldi(L, "DESCRIPTOR_TYPE_SINT64",    UPB_DESCRIPTOR_TYPE_SINT64);
-
-  lupb_setfieldi(L, "DEF_MSG",      UPB_DEF_MSG);
-  lupb_setfieldi(L, "DEF_FIELD",    UPB_DEF_FIELD);
-  lupb_setfieldi(L, "DEF_ENUM",     UPB_DEF_ENUM);
-  lupb_setfieldi(L, "DEF_SERVICE",  UPB_DEF_SERVICE);
-  lupb_setfieldi(L, "DEF_ANY",      UPB_DEF_ANY);
-
-  lupb_setfieldi(L, "HANDLER_INT32",       UPB_HANDLER_INT32);
-  lupb_setfieldi(L, "HANDLER_INT64",       UPB_HANDLER_INT64);
-  lupb_setfieldi(L, "HANDLER_UINT32",      UPB_HANDLER_UINT32);
-  lupb_setfieldi(L, "HANDLER_UINT64",      UPB_HANDLER_UINT64);
-  lupb_setfieldi(L, "HANDLER_FLOAT",       UPB_HANDLER_FLOAT);
-  lupb_setfieldi(L, "HANDLER_DOUBLE",      UPB_HANDLER_DOUBLE);
-  lupb_setfieldi(L, "HANDLER_BOOL",        UPB_HANDLER_BOOL);
-  lupb_setfieldi(L, "HANDLER_STARTSTR",    UPB_HANDLER_STARTSTR);
-  lupb_setfieldi(L, "HANDLER_STRING",      UPB_HANDLER_STRING);
-  lupb_setfieldi(L, "HANDLER_ENDSTR",      UPB_HANDLER_ENDSTR);
-  lupb_setfieldi(L, "HANDLER_STARTSUBMSG", UPB_HANDLER_STARTSUBMSG);
-  lupb_setfieldi(L, "HANDLER_ENDSUBMSG",   UPB_HANDLER_ENDSUBMSG);
-  lupb_setfieldi(L, "HANDLER_STARTSEQ",    UPB_HANDLER_STARTSEQ);
-  lupb_setfieldi(L, "HANDLER_ENDSEQ",      UPB_HANDLER_ENDSEQ);
-
-  lupb_setfieldi(L, "SYNTAX_PROTO2",  UPB_SYNTAX_PROTO2);
-  lupb_setfieldi(L, "SYNTAX_PROTO3",  UPB_SYNTAX_PROTO3);
+  lupb_def_registertypes(L);
+  lupb_msg_registertypes(L);
 
   return 1;  /* Return package table. */
 }