Merge branch 'master' into apitweaks

13 files changed, 567 insertions, 1900 deletions

diff --git a/tests/conformance_upb.c b/tests/conformance_upb.c
index 8cb42c6..a0526d7 100644
--- a/tests/conformance_upb.c
+++ b/tests/conformance_upb.c
@@ -39,7 +39,7 @@ void CheckedWrite(int fd, const void *buf, size_t len) {
   }
 }
 
-bool stringview_eql(upb_strview view, const char *str) {
+bool strview_eql(upb_strview view, const char *str) {
   return view.size == strlen(str) && memcmp(view.data, str, view.size) == 0;
 }
 
@@ -50,8 +50,8 @@ void DoTest(
     const conformance_ConformanceRequest* request,
     conformance_ConformanceResponse *response,
     upb_arena *arena) {
-  if (!stringview_eql(conformance_ConformanceRequest_message_type(request),
-                      proto3_msg)) {
+  if (!strview_eql(conformance_ConformanceRequest_message_type(request),
+                   proto3_msg)) {
     static const char msg[] = "Only proto3 for now.";
     conformance_ConformanceResponse_set_skipped(
         response, upb_strview_make(msg, sizeof(msg)));
@@ -130,7 +130,7 @@ void DoTest(
 }
 
 bool DoTestIo() {
-  upb_arena arena;
+  upb_arena *arena;
   upb_alloc *alloc;
   upb_status status;
   char *serialized_input;
@@ -145,8 +145,8 @@ bool DoTestIo() {
     return false;
   }
 
-  upb_arena_init(&arena);
-  alloc = upb_arena_alloc(&arena);
+  arena = upb_arena_new();
+  alloc = upb_arena_alloc(arena);
   serialized_input = upb_malloc(alloc, input_size);
 
   if (!CheckedRead(STDIN_FILENO, serialized_input, input_size)) {
@@ -154,25 +154,27 @@ bool DoTestIo() {
     exit(1);
   }
 
-  request = conformance_ConformanceRequest_parse(serialized_input, input_size,
-                                                 &arena);
-  response = conformance_ConformanceResponse_new(&arena);
+  request =
+      conformance_ConformanceRequest_parse(serialized_input, input_size, arena);
+  response = conformance_ConformanceResponse_new(arena);
 
   if (request) {
-    DoTest(request, response, &arena);
+    DoTest(request, response, arena);
   } else {
     fprintf(stderr, "conformance_upb: parse of ConformanceRequest failed: %s\n",
             upb_status_errmsg(&status));
   }
 
   serialized_output = conformance_ConformanceResponse_serialize(
-      response, &arena, &output_size);
+      response, arena, &output_size);
 
   CheckedWrite(STDOUT_FILENO, &output_size, sizeof(uint32_t));
   CheckedWrite(STDOUT_FILENO, serialized_output, output_size);
 
   test_count++;
 
+  upb_arena_free(arena);
+
   return true;
 }
 
diff --git a/tests/json/test.upbdefs.c b/tests/json/test.upbdefs.c
deleted file mode 100644
index 826be52..0000000
--- a/tests/json/test.upbdefs.c
+++ /dev/null
@@ -1,311 +0,0 @@
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     tests/json/test.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#include "upb/def.h"
-static const upb_msgdef msgs[8];
-static const upb_fielddef fields[37];
-static const upb_enumdef enums[1];
-static const upb_tabent strentries[64];
-static const upb_tabval arrays[49];
-
-#ifdef UPB_DEBUG_REFS
-static upb_inttable reftables[92];
-#endif
-
-static const upb_msgdef msgs[8] = {
-  UPB_MSGDEF_INIT("upb.test.json.SubMessage", 4, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[0], 2, 1), UPB_STRTABLE_INIT(1, 3, UPB_CTYPE_PTR, 2, &strentries[0]), false, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[0], &reftables[1]),
-  UPB_MSGDEF_INIT("upb.test.json.TestMessage", 73, 8, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[2], 26, 24), UPB_STRTABLE_INIT(24, 31, UPB_CTYPE_PTR, 5, &strentries[4]), false, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[2], &reftables[3]),
-  UPB_MSGDEF_INIT("upb.test.json.TestMessage.MapBoolStringEntry", 7, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[28], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[36]), true, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[4], &reftables[5]),
-  UPB_MSGDEF_INIT("upb.test.json.TestMessage.MapInt32StringEntry", 7, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[31], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[40]), true, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[6], &reftables[7]),
-  UPB_MSGDEF_INIT("upb.test.json.TestMessage.MapStringBoolEntry", 7, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[34], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[44]), true, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[8], &reftables[9]),
-  UPB_MSGDEF_INIT("upb.test.json.TestMessage.MapStringInt32Entry", 7, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[37], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[48]), true, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[10], &reftables[11]),
-  UPB_MSGDEF_INIT("upb.test.json.TestMessage.MapStringMsgEntry", 8, 1, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[40], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[52]), true, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[12], &reftables[13]),
-  UPB_MSGDEF_INIT("upb.test.json.TestMessage.MapStringStringEntry", 9, 0, UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_PTR, 0, NULL, &arrays[43], 3, 2), UPB_STRTABLE_INIT(2, 3, UPB_CTYPE_PTR, 2, &strentries[56]), true, UPB_SYNTAX_PROTO3, UPB_WELLKNOWN_UNSPECIFIED, &reftables[14], &reftables[15]),
-};
-
-static const upb_fielddef fields[37] = {
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "foo", 1, &msgs[0], NULL, 3, 0, {0},&reftables[16], &reftables[17]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "key", 1, &msgs[7], NULL, 3, 0, {0},&reftables[18], &reftables[19]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "key", 1, &msgs[3], NULL, 3, 0, {0},&reftables[20], &reftables[21]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "key", 1, &msgs[2], NULL, 3, 0, {0},&reftables[22], &reftables[23]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "key", 1, &msgs[5], NULL, 3, 0, {0},&reftables[24], &reftables[25]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "key", 1, &msgs[4], NULL, 3, 0, {0},&reftables[26], &reftables[27]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "key", 1, &msgs[6], NULL, 5, 1, {0},&reftables[28], &reftables[29]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "map_bool_string", 22, &msgs[1], (const upb_def*)(&msgs[2]), 23, 4, {0},&reftables[30], &reftables[31]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "map_int32_string", 21, &msgs[1], (const upb_def*)(&msgs[3]), 20, 3, {0},&reftables[32], &reftables[33]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "map_string_bool", 24, &msgs[1], (const upb_def*)(&msgs[4]), 29, 6, {0},&reftables[34], &reftables[35]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "map_string_int32", 23, &msgs[1], (const upb_def*)(&msgs[5]), 26, 5, {0},&reftables[36], &reftables[37]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "map_string_msg", 25, &msgs[1], (const upb_def*)(&msgs[6]), 32, 7, {0},&reftables[38], &reftables[39]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "map_string_string", 20, &msgs[1], (const upb_def*)(&msgs[7]), 17, 2, {0},&reftables[40], &reftables[41]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "optional_bool", 7, &msgs[1], NULL, 43, 14, {0},&reftables[42], &reftables[43]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BYTES, 0, false, false, false, false, "optional_bytes", 6, &msgs[1], NULL, 40, 13, {0},&reftables[44], &reftables[45]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_ENUM, 0, false, false, false, false, "optional_enum", 9, &msgs[1], (const upb_def*)(&enums[0]), 44, 15, {0},&reftables[46], &reftables[47]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "optional_int32", 1, &msgs[1], NULL, 33, 8, {0},&reftables[48], &reftables[49]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT64, UPB_INTFMT_VARIABLE, false, false, false, false, "optional_int64", 2, &msgs[1], NULL, 34, 9, {0},&reftables[50], &reftables[51]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "optional_msg", 8, &msgs[1], (const upb_def*)(&msgs[0]), 11, 0, {0},&reftables[52], &reftables[53]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "optional_string", 5, &msgs[1], NULL, 37, 12, {0},&reftables[54], &reftables[55]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "optional_uint32", 3, &msgs[1], NULL, 35, 10, {0},&reftables[56], &reftables[57]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT64, UPB_INTFMT_VARIABLE, false, false, false, false, "optional_uint64", 4, &msgs[1], NULL, 36, 11, {0},&reftables[58], &reftables[59]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_BOOL, 0, false, false, false, false, "repeated_bool", 17, &msgs[1], NULL, 69, 22, {0},&reftables[60], &reftables[61]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_BYTES, 0, false, false, false, false, "repeated_bytes", 16, &msgs[1], NULL, 64, 21, {0},&reftables[62], &reftables[63]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_ENUM, 0, false, false, false, false, "repeated_enum", 19, &msgs[1], (const upb_def*)(&enums[0]), 72, 23, {0},&reftables[64], &reftables[65]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "repeated_int32", 11, &msgs[1], NULL, 47, 16, {0},&reftables[66], &reftables[67]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_INT64, UPB_INTFMT_VARIABLE, false, false, false, false, "repeated_int64", 12, &msgs[1], NULL, 50, 17, {0},&reftables[68], &reftables[69]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_MESSAGE, 0, false, false, false, false, "repeated_msg", 18, &msgs[1], (const upb_def*)(&msgs[0]), 14, 1, {0},&reftables[70], &reftables[71]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_STRING, 0, false, false, false, false, "repeated_string", 15, &msgs[1], NULL, 59, 20, {0},&reftables[72], &reftables[73]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_UINT32, UPB_INTFMT_VARIABLE, false, false, false, false, "repeated_uint32", 13, &msgs[1], NULL, 53, 18, {0},&reftables[74], &reftables[75]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_REPEATED, UPB_TYPE_UINT64, UPB_INTFMT_VARIABLE, false, false, false, false, "repeated_uint64", 14, &msgs[1], NULL, 56, 19, {0},&reftables[76], &reftables[77]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_MESSAGE, 0, false, false, false, false, "value", 2, &msgs[6], (const upb_def*)(&msgs[0]), 4, 0, {0},&reftables[78], &reftables[79]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "value", 2, &msgs[7], NULL, 6, 1, {0},&reftables[80], &reftables[81]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_INT32, UPB_INTFMT_VARIABLE, false, false, false, false, "value", 2, &msgs[5], NULL, 6, 1, {0},&reftables[82], &reftables[83]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "value", 2, &msgs[2], NULL, 4, 1, {0},&reftables[84], &reftables[85]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_BOOL, 0, false, false, false, false, "value", 2, &msgs[4], NULL, 6, 1, {0},&reftables[86], &reftables[87]),
-  UPB_FIELDDEF_INIT(UPB_LABEL_OPTIONAL, UPB_TYPE_STRING, 0, false, false, false, false, "value", 2, &msgs[3], NULL, 4, 1, {0},&reftables[88], &reftables[89]),
-};
-
-static const upb_enumdef enums[1] = {
-  UPB_ENUMDEF_INIT("upb.test.json.MyEnum", UPB_STRTABLE_INIT(3, 3, UPB_CTYPE_INT32, 2, &strentries[60]), UPB_INTTABLE_INIT(0, 0, UPB_CTYPE_CSTR, 0, NULL, &arrays[46], 3, 3), 0, &reftables[90], &reftables[91]),
-};
-
-static const upb_tabent strentries[64] = {
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "foo"), UPB_TABVALUE_PTR_INIT(&fields[0]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "repeated_enum"), UPB_TABVALUE_PTR_INIT(&fields[24]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "optional_enum"), UPB_TABVALUE_PTR_INIT(&fields[15]), &strentries[31]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "optional_int32"), UPB_TABVALUE_PTR_INIT(&fields[16]), NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "repeated_bool"), UPB_TABVALUE_PTR_INIT(&fields[22]), NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "repeated_bytes"), UPB_TABVALUE_PTR_INIT(&fields[23]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "optional_int64"), UPB_TABVALUE_PTR_INIT(&fields[17]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "optional_string"), UPB_TABVALUE_PTR_INIT(&fields[19]), NULL},
-  {UPB_TABKEY_STR("\015", "\000", "\000", "\000", "optional_bool"), UPB_TABVALUE_PTR_INIT(&fields[13]), &strentries[30]},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "map_int32_string"), UPB_TABVALUE_PTR_INIT(&fields[8]), NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "optional_bytes"), UPB_TABVALUE_PTR_INIT(&fields[14]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "optional_msg"), UPB_TABVALUE_PTR_INIT(&fields[18]), NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "repeated_int32"), UPB_TABVALUE_PTR_INIT(&fields[25]), &strentries[35]},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "repeated_uint32"), UPB_TABVALUE_PTR_INIT(&fields[29]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "map_bool_string"), UPB_TABVALUE_PTR_INIT(&fields[7]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "optional_uint64"), UPB_TABVALUE_PTR_INIT(&fields[21]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "optional_uint32"), UPB_TABVALUE_PTR_INIT(&fields[20]), &strentries[32]},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "map_string_bool"), UPB_TABVALUE_PTR_INIT(&fields[9]), NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "repeated_int64"), UPB_TABVALUE_PTR_INIT(&fields[26]), &strentries[34]},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\016", "\000", "\000", "\000", "map_string_msg"), UPB_TABVALUE_PTR_INIT(&fields[11]), NULL},
-  {UPB_TABKEY_STR("\020", "\000", "\000", "\000", "map_string_int32"), UPB_TABVALUE_PTR_INIT(&fields[10]), NULL},
-  {UPB_TABKEY_STR("\021", "\000", "\000", "\000", "map_string_string"), UPB_TABVALUE_PTR_INIT(&fields[12]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "repeated_uint64"), UPB_TABVALUE_PTR_INIT(&fields[30]), NULL},
-  {UPB_TABKEY_STR("\014", "\000", "\000", "\000", "repeated_msg"), UPB_TABVALUE_PTR_INIT(&fields[27]), NULL},
-  {UPB_TABKEY_STR("\017", "\000", "\000", "\000", "repeated_string"), UPB_TABVALUE_PTR_INIT(&fields[28]), NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "key"), UPB_TABVALUE_PTR_INIT(&fields[3]), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "value"), UPB_TABVALUE_PTR_INIT(&fields[34]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "key"), UPB_TABVALUE_PTR_INIT(&fields[2]), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "value"), UPB_TABVALUE_PTR_INIT(&fields[36]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "key"), UPB_TABVALUE_PTR_INIT(&fields[5]), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "value"), UPB_TABVALUE_PTR_INIT(&fields[35]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "key"), UPB_TABVALUE_PTR_INIT(&fields[4]), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "value"), UPB_TABVALUE_PTR_INIT(&fields[33]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "key"), UPB_TABVALUE_PTR_INIT(&fields[6]), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "value"), UPB_TABVALUE_PTR_INIT(&fields[31]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\003", "\000", "\000", "\000", "key"), UPB_TABVALUE_PTR_INIT(&fields[1]), NULL},
-  {UPB_TABKEY_STR("\005", "\000", "\000", "\000", "value"), UPB_TABVALUE_PTR_INIT(&fields[32]), NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_NONE, UPB_TABVALUE_EMPTY_INIT, NULL},
-  {UPB_TABKEY_STR("\001", "\000", "\000", "\000", "A"), UPB_TABVALUE_INT_INIT(0), NULL},
-  {UPB_TABKEY_STR("\001", "\000", "\000", "\000", "B"), UPB_TABVALUE_INT_INIT(1), &strentries[63]},
-  {UPB_TABKEY_STR("\001", "\000", "\000", "\000", "C"), UPB_TABVALUE_INT_INIT(2), NULL},
-};
-
-static const upb_tabval arrays[49] = {
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[0]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[16]),
-  UPB_TABVALUE_PTR_INIT(&fields[17]),
-  UPB_TABVALUE_PTR_INIT(&fields[20]),
-  UPB_TABVALUE_PTR_INIT(&fields[21]),
-  UPB_TABVALUE_PTR_INIT(&fields[19]),
-  UPB_TABVALUE_PTR_INIT(&fields[14]),
-  UPB_TABVALUE_PTR_INIT(&fields[13]),
-  UPB_TABVALUE_PTR_INIT(&fields[18]),
-  UPB_TABVALUE_PTR_INIT(&fields[15]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[25]),
-  UPB_TABVALUE_PTR_INIT(&fields[26]),
-  UPB_TABVALUE_PTR_INIT(&fields[29]),
-  UPB_TABVALUE_PTR_INIT(&fields[30]),
-  UPB_TABVALUE_PTR_INIT(&fields[28]),
-  UPB_TABVALUE_PTR_INIT(&fields[23]),
-  UPB_TABVALUE_PTR_INIT(&fields[22]),
-  UPB_TABVALUE_PTR_INIT(&fields[27]),
-  UPB_TABVALUE_PTR_INIT(&fields[24]),
-  UPB_TABVALUE_PTR_INIT(&fields[12]),
-  UPB_TABVALUE_PTR_INIT(&fields[8]),
-  UPB_TABVALUE_PTR_INIT(&fields[7]),
-  UPB_TABVALUE_PTR_INIT(&fields[10]),
-  UPB_TABVALUE_PTR_INIT(&fields[9]),
-  UPB_TABVALUE_PTR_INIT(&fields[11]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[3]),
-  UPB_TABVALUE_PTR_INIT(&fields[34]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[2]),
-  UPB_TABVALUE_PTR_INIT(&fields[36]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[5]),
-  UPB_TABVALUE_PTR_INIT(&fields[35]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[4]),
-  UPB_TABVALUE_PTR_INIT(&fields[33]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[6]),
-  UPB_TABVALUE_PTR_INIT(&fields[31]),
-  UPB_TABVALUE_EMPTY_INIT,
-  UPB_TABVALUE_PTR_INIT(&fields[1]),
-  UPB_TABVALUE_PTR_INIT(&fields[32]),
-  UPB_TABVALUE_PTR_INIT("A"),
-  UPB_TABVALUE_PTR_INIT("B"),
-  UPB_TABVALUE_PTR_INIT("C"),
-};
-
-#ifdef UPB_DEBUG_REFS
-static upb_inttable reftables[92] = {
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-  UPB_EMPTY_INTTABLE_INIT(UPB_CTYPE_PTR),
-};
-#endif
-
-static const upb_msgdef *refm(const upb_msgdef *m, const void *owner) {
-  upb_msgdef_ref(m, owner);
-  return m;
-}
-
-static const upb_enumdef *refe(const upb_enumdef *e, const void *owner) {
-  upb_enumdef_ref(e, owner);
-  return e;
-}
-
-/* Public API. */
-const upb_msgdef *upbdefs_upb_test_json_SubMessage_get(const void *owner) { return refm(&msgs[0], owner); }
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_get(const void *owner) { return refm(&msgs[1], owner); }
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_get(const void *owner) { return refm(&msgs[2], owner); }
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_get(const void *owner) { return refm(&msgs[3], owner); }
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_get(const void *owner) { return refm(&msgs[4], owner); }
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_get(const void *owner) { return refm(&msgs[5], owner); }
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_get(const void *owner) { return refm(&msgs[6], owner); }
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringStringEntry_get(const void *owner) { return refm(&msgs[7], owner); }
-
-const upb_enumdef *upbdefs_upb_test_json_MyEnum_get(const void *owner) { return refe(&enums[0], owner); }
diff --git a/tests/json/test.upbdefs.h b/tests/json/test.upbdefs.h
deleted file mode 100644
index 065c001..0000000
--- a/tests/json/test.upbdefs.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/* This file contains accessors for a set of compiled-in defs.
- * Note that unlike Google's protobuf, it does *not* define
- * generated classes or any other kind of data structure for
- * actually storing protobufs.  It only contains *defs* which
- * let you reflect over a protobuf *schema*.
- */
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     tests/json/test.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#ifndef TESTS_JSON_TEST_PROTO_UPB_H_
-#define TESTS_JSON_TEST_PROTO_UPB_H_
-
-#include "upb/def.h"
-
-UPB_BEGIN_EXTERN_C
-
-/* MessageDefs: call these functions to get a ref to a msgdef. */
-const upb_msgdef *upbdefs_upb_test_json_SubMessage_get(const void *owner);
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_get(const void *owner);
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_get(const void *owner);
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_get(const void *owner);
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_get(const void *owner);
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_get(const void *owner);
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_get(const void *owner);
-const upb_msgdef *upbdefs_upb_test_json_TestMessage_MapStringStringEntry_get(const void *owner);
-
-/* EnumDefs: call these functions to get a ref to an enumdef. */
-const upb_enumdef *upbdefs_upb_test_json_MyEnum_get(const void *owner);
-
-/* Functions to test whether this message is of a certain type. */
-UPB_INLINE bool upbdefs_upb_test_json_SubMessage_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.SubMessage") == 0;
-}
-UPB_INLINE bool upbdefs_upb_test_json_TestMessage_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.TestMessage") == 0;
-}
-UPB_INLINE bool upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.TestMessage.MapBoolStringEntry") == 0;
-}
-UPB_INLINE bool upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.TestMessage.MapInt32StringEntry") == 0;
-}
-UPB_INLINE bool upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.TestMessage.MapStringBoolEntry") == 0;
-}
-UPB_INLINE bool upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.TestMessage.MapStringInt32Entry") == 0;
-}
-UPB_INLINE bool upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.TestMessage.MapStringMsgEntry") == 0;
-}
-UPB_INLINE bool upbdefs_upb_test_json_TestMessage_MapStringStringEntry_is(const upb_msgdef *m) {
-  return strcmp(upb_msgdef_fullname(m), "upb.test.json.TestMessage.MapStringStringEntry") == 0;
-}
-
-/* Functions to test whether this enum is of a certain type. */
-UPB_INLINE bool upbdefs_upb_test_json_MyEnum_is(const upb_enumdef *e) {
-  return strcmp(upb_enumdef_fullname(e), "upb.test.json.MyEnum") == 0;
-}
-
-
-/* Functions to get a fielddef from a msgdef reference. */
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_SubMessage_f_foo(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_SubMessage_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_f_key(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_f_key(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_f_key(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_f_key(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_f_key(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringStringEntry_f_key(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringStringEntry_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_MapStringStringEntry_f_value(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringStringEntry_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_map_bool_string(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 22); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_map_int32_string(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 21); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_map_string_bool(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 24); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_map_string_int32(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 23); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_map_string_msg(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 25); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_map_string_string(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 20); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_bool(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 7); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_bytes(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 6); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_enum(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 9); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_int32(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 1); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_int64(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 2); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_msg(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 8); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_string(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 5); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_uint32(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 3); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_optional_uint64(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 4); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_bool(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 17); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_bytes(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 16); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_enum(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 19); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_int32(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 11); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_int64(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 12); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_msg(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 18); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_string(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 15); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_uint32(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 13); }
-UPB_INLINE const upb_fielddef *upbdefs_upb_test_json_TestMessage_f_repeated_uint64(const upb_msgdef *m) { UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m)); return upb_msgdef_itof(m, 14); }
-
-UPB_END_EXTERN_C
-
-#ifdef __cplusplus
-
-namespace upbdefs {
-namespace upb {
-namespace test {
-namespace json {
-
-class MyEnum : public ::upb::reffed_ptr<const ::upb::EnumDef> {
- public:
-  MyEnum(const ::upb::EnumDef* e, const void *ref_donor = NULL)
-      : reffed_ptr(e, ref_donor) {
-    UPB_ASSERT(upbdefs_upb_test_json_MyEnum_is(e));
-  }
-  static MyEnum get() {
-    const ::upb::EnumDef* e = upbdefs_upb_test_json_MyEnum_get(&e);
-    return MyEnum(e, &e);
-  }
-};
-
-class SubMessage : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  SubMessage(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_upb_test_json_SubMessage_is(m));
-  }
-
-  static SubMessage get() {
-    const ::upb::MessageDef* m = upbdefs_upb_test_json_SubMessage_get(&m);
-    return SubMessage(m, &m);
-  }
-};
-
-class TestMessage : public ::upb::reffed_ptr<const ::upb::MessageDef> {
- public:
-  TestMessage(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-      : reffed_ptr(m, ref_donor) {
-    UPB_ASSERT(upbdefs_upb_test_json_TestMessage_is(m));
-  }
-
-  static TestMessage get() {
-    const ::upb::MessageDef* m = upbdefs_upb_test_json_TestMessage_get(&m);
-    return TestMessage(m, &m);
-  }
-
-  class MapBoolStringEntry : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    MapBoolStringEntry(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_is(m));
-    }
-
-    static MapBoolStringEntry get() {
-      const ::upb::MessageDef* m = upbdefs_upb_test_json_TestMessage_MapBoolStringEntry_get(&m);
-      return MapBoolStringEntry(m, &m);
-    }
-  };
-
-  class MapInt32StringEntry : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    MapInt32StringEntry(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_is(m));
-    }
-
-    static MapInt32StringEntry get() {
-      const ::upb::MessageDef* m = upbdefs_upb_test_json_TestMessage_MapInt32StringEntry_get(&m);
-      return MapInt32StringEntry(m, &m);
-    }
-  };
-
-  class MapStringBoolEntry : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    MapStringBoolEntry(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_is(m));
-    }
-
-    static MapStringBoolEntry get() {
-      const ::upb::MessageDef* m = upbdefs_upb_test_json_TestMessage_MapStringBoolEntry_get(&m);
-      return MapStringBoolEntry(m, &m);
-    }
-  };
-
-  class MapStringInt32Entry : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    MapStringInt32Entry(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_is(m));
-    }
-
-    static MapStringInt32Entry get() {
-      const ::upb::MessageDef* m = upbdefs_upb_test_json_TestMessage_MapStringInt32Entry_get(&m);
-      return MapStringInt32Entry(m, &m);
-    }
-  };
-
-  class MapStringMsgEntry : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    MapStringMsgEntry(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_is(m));
-    }
-
-    static MapStringMsgEntry get() {
-      const ::upb::MessageDef* m = upbdefs_upb_test_json_TestMessage_MapStringMsgEntry_get(&m);
-      return MapStringMsgEntry(m, &m);
-    }
-  };
-
-  class MapStringStringEntry : public ::upb::reffed_ptr<const ::upb::MessageDef> {
-   public:
-    MapStringStringEntry(const ::upb::MessageDef* m, const void *ref_donor = NULL)
-        : reffed_ptr(m, ref_donor) {
-      UPB_ASSERT(upbdefs_upb_test_json_TestMessage_MapStringStringEntry_is(m));
-    }
-
-    static MapStringStringEntry get() {
-      const ::upb::MessageDef* m = upbdefs_upb_test_json_TestMessage_MapStringStringEntry_get(&m);
-      return MapStringStringEntry(m, &m);
-    }
-  };
-};
-
-}  /* namespace json */
-}  /* namespace test */
-}  /* namespace upb */
-}  /* namespace upbdefs */
-
-#endif  /* __cplusplus */
-
-#endif  /* TESTS_JSON_TEST_PROTO_UPB_H_ */
diff --git a/tests/json/test_json.cc b/tests/json/test_json.cc
index 815d292..3dc4a6c 100644
--- a/tests/json/test_json.cc
+++ b/tests/json/test_json.cc
@@ -144,7 +144,7 @@ class StringSink {
   }
   ~StringSink() { }
 
-  upb_bytessink* Sink() { return &bytessink_; }
+  upb_bytessink Sink() { return bytessink_; }
 
   const std::string& Data() { return s_; }
 
@@ -169,16 +169,15 @@ class StringSink {
 void test_json_roundtrip_message(const char* json_src,
                                  const char* json_expected,
                                  const upb::Handlers* serialize_handlers,
-                                 const upb::json::ParserMethod* parser_method,
+                                 const upb::json::ParserMethodPtr parser_method,
                                  int seam) {
   VerboseParserEnvironment env(verbose);
   StringSink data_sink;
-  upb::json::Printer* printer = upb::json::Printer::Create(
-      env.env(), serialize_handlers, data_sink.Sink());
-  upb::json::Parser* parser =
-      upb::json::Parser::Create(
-          env.env(), parser_method, NULL, printer->input(), false);
-  env.ResetBytesSink(parser->input());
+  upb::json::PrinterPtr printer = upb::json::PrinterPtr::Create(
+      env.arena(), serialize_handlers, data_sink.Sink());
+  upb::json::ParserPtr parser = upb::json::ParserPtr::Create(
+      env.arena(), parser_method, NULL, printer.input(), env.status(), false);
+  env.ResetBytesSink(parser.input());
   env.Reset(json_src, strlen(json_src), false, false);
 
   bool ok = env.Start() &&
@@ -203,12 +202,16 @@ void test_json_roundtrip_message(const char* json_src,
 // Starts with a message in JSON format, parses and directly serializes again,
 // and compares the result.
 void test_json_roundtrip() {
-  upb::reffed_ptr<const upb::MessageDef> md(
-      upbdefs::upb::test::json::TestMessage::get());
-  upb::reffed_ptr<const upb::Handlers> serialize_handlers(
-      upb::json::Printer::NewHandlers(md.get(), false));
-  upb::reffed_ptr<const upb::json::ParserMethod> parser_method(
-      upb::json::ParserMethod::New(md.get()));
+  upb::SymbolTable symtab;
+  upb::HandlerCache serialize_handlercache(
+      upb::json::PrinterPtr::NewCache(false));
+  upb::json::CodeCache parse_codecache;
+
+  upb::MessageDefPtr md(upb_test_json_TestMessage_getmsgdef(symtab.ptr()));
+  ASSERT(md);
+  const upb::Handlers* serialize_handlers = serialize_handlercache.Get(md);
+  const upb::json::ParserMethodPtr parser_method = parse_codecache.Get(md);
+  ASSERT(serialize_handlers);
 
   for (const TestCase* test_case = kTestRoundtripMessages;
        test_case->input != NULL; test_case++) {
@@ -219,12 +222,12 @@ void test_json_roundtrip() {
 
     for (size_t i = 0; i < strlen(test_case->input); i++) {
       test_json_roundtrip_message(test_case->input, expected,
-                                  serialize_handlers.get(), parser_method.get(),
-                                  i);
+                                  serialize_handlers, parser_method, i);
     }
   }
 
-  serialize_handlers = upb::json::Printer::NewHandlers(md.get(), true);
+  serialize_handlercache = upb::json::PrinterPtr::NewCache(true);
+  serialize_handlers = serialize_handlercache.Get(md);
 
   for (const TestCase* test_case = kTestRoundtripMessagesPreserve;
        test_case->input != NULL; test_case++) {
@@ -235,8 +238,7 @@ void test_json_roundtrip() {
 
     for (size_t i = 0; i < strlen(test_case->input); i++) {
       test_json_roundtrip_message(test_case->input, expected,
-                                  serialize_handlers.get(), parser_method.get(),
-                                  i);
+                                  serialize_handlers, parser_method, i);
     }
   }
 }
diff --git a/tests/pb/test_decoder.cc b/tests/pb/test_decoder.cc
index e44f60c..7450445 100644
--- a/tests/pb/test_decoder.cc
+++ b/tests/pb/test_decoder.cc
@@ -36,6 +36,7 @@
 
 #include "tests/test_util.h"
 #include "tests/upb_test.h"
+#include "tests/pb/test_decoder.upbdefs.h"
 
 #ifdef AMALGAMATED
 #include "upb.h"
@@ -241,16 +242,8 @@ void indentbuf(string *buf, int depth) {
   buf->append(2 * depth, ' ');
 }
 
-void check_stack_alignment() {
-#ifdef UPB_USE_JIT_X64
-  void *rsp = __builtin_frame_address(0);
-  ASSERT(((uintptr_t)rsp % 16) == 0);
-#endif
-}
-
 #define NUMERIC_VALUE_HANDLER(member, ctype, fmt)                   \
   bool value_##member(int* depth, const uint32_t* num, ctype val) { \
-    check_stack_alignment();                                        \
     indentbuf(&output, *depth);                                     \
     appendf(&output, "%" PRIu32 ":%" fmt "\n", *num, val);          \
     return true;                                                    \
@@ -264,24 +257,21 @@ NUMERIC_VALUE_HANDLER(float,  float,    "g")
 NUMERIC_VALUE_HANDLER(double, double,   "g")
 
 bool value_bool(int* depth, const uint32_t* num, bool val) {
-  check_stack_alignment();
   indentbuf(&output, *depth);
   appendf(&output, "%" PRIu32 ":%s\n", *num, val ? "true" : "false");
   return true;
 }
 
 int* startstr(int* depth, const uint32_t* num, size_t size_hint) {
-  check_stack_alignment();
   indentbuf(&output, *depth);
   appendf(&output, "%" PRIu32 ":(%zu)\"", *num, size_hint);
   return depth + 1;
 }
 
 size_t value_string(int* depth, const uint32_t* num, const char* buf,
-                    size_t n, const upb::BufferHandle* handle) {
+                    size_t n, const upb_bufhandle* handle) {
   UPB_UNUSED(num);
   UPB_UNUSED(depth);
-  check_stack_alignment();
   output.append(buf, n);
   ASSERT(handle == &global_handle);
   return n;
@@ -289,7 +279,6 @@ size_t value_string(int* depth, const uint32_t* num, const char* buf,
 
 bool endstr(int* depth, const uint32_t* num) {
   UPB_UNUSED(num);
-  check_stack_alignment();
   output.append("\n");
   indentbuf(&output, *depth);
   appendf(&output, "%" PRIu32 ":\"\n", *num);
@@ -297,7 +286,6 @@ bool endstr(int* depth, const uint32_t* num) {
 }
 
 int* startsubmsg(int* depth, const uint32_t* num) {
-  check_stack_alignment();
   indentbuf(&output, *depth);
   appendf(&output, "%" PRIu32 ":{\n", *num);
   return depth + 1;
@@ -305,14 +293,12 @@ int* startsubmsg(int* depth, const uint32_t* num) {
 
 bool endsubmsg(int* depth, const uint32_t* num) {
   UPB_UNUSED(num);
-  check_stack_alignment();
   indentbuf(&output, *depth);
   output.append("}\n");
   return true;
 }
 
 int* startseq(int* depth, const uint32_t* num) {
-  check_stack_alignment();
   indentbuf(&output, *depth);
   appendf(&output, "%" PRIu32 ":[\n", *num);
   return depth + 1;
@@ -320,14 +306,12 @@ int* startseq(int* depth, const uint32_t* num) {
 
 bool endseq(int* depth, const uint32_t* num) {
   UPB_UNUSED(num);
-  check_stack_alignment();
   indentbuf(&output, *depth);
   output.append("]\n");
   return true;
 }
 
 bool startmsg(int* depth) {
-  check_stack_alignment();
   indentbuf(&output, *depth);
   output.append("<\n");
   return true;
@@ -335,7 +319,6 @@ bool startmsg(int* depth) {
 
 bool endmsg(int* depth, upb_status* status) {
   UPB_UNUSED(status);
-  check_stack_alignment();
   indentbuf(&output, *depth);
   output.append(">\n");
   return true;
@@ -347,13 +330,13 @@ void free_uint32(void *val) {
 }
 
 template<class T, bool F(int*, const uint32_t*, T)>
-void doreg(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void doreg(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  ASSERT(h->SetValueHandler<T>(f, UpbBindT(F, new uint32_t(num))));
-  if (f->IsSequence()) {
-    ASSERT(h->SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
-    ASSERT(h->SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
+  ASSERT(h.SetValueHandler<T>(f, UpbBind(F, new uint32_t(num))));
+  if (f.IsSequence()) {
+    ASSERT(h.SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
+    ASSERT(h.SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
   }
 }
 
@@ -367,7 +350,7 @@ uint32_t rep_fn(uint32_t fn) {
 #define UNKNOWN_FIELD 666
 
 template <class T, bool F(int*, const uint32_t*, T)>
-void reg(upb_handlers *h, upb_descriptortype_t type) {
+void reg(upb::HandlersPtr h, upb_descriptortype_t type) {
   // We register both a repeated and a non-repeated field for every type.
   // For the non-repeated field we make the field number the same as the
   // type.  For the repeated field we make it a function of the type.
@@ -375,187 +358,88 @@ void reg(upb_handlers *h, upb_descriptortype_t type) {
   doreg<T, F>(h, rep_fn(type));
 }
 
-void regseq(upb::Handlers* h, const upb::FieldDef* f, uint32_t num) {
-  ASSERT(h->SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
-  ASSERT(h->SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
+void regseq(upb::HandlersPtr h, upb::FieldDefPtr f, uint32_t num) {
+  ASSERT(h.SetStartSequenceHandler(f, UpbBind(startseq, new uint32_t(num))));
+  ASSERT(h.SetEndSequenceHandler(f, UpbBind(endseq, new uint32_t(num))));
 }
 
-void reg_subm(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void reg_subm(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  if (f->IsSequence()) regseq(h, f, num);
+  if (f.IsSequence()) regseq(h, f, num);
   ASSERT(
-      h->SetStartSubMessageHandler(f, UpbBind(startsubmsg, new uint32_t(num))));
-  ASSERT(h->SetEndSubMessageHandler(f, UpbBind(endsubmsg, new uint32_t(num))));
-  ASSERT(upb_handlers_setsubhandlers(h, f, h));
+      h.SetStartSubMessageHandler(f, UpbBind(startsubmsg, new uint32_t(num))));
+  ASSERT(h.SetEndSubMessageHandler(f, UpbBind(endsubmsg, new uint32_t(num))));
 }
 
-void reg_str(upb_handlers *h, uint32_t num) {
-  const upb_fielddef *f = upb_msgdef_itof(upb_handlers_msgdef(h), num);
+void reg_str(upb::HandlersPtr h, uint32_t num) {
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(num);
   ASSERT(f);
-  if (f->IsSequence()) regseq(h, f, num);
-  ASSERT(h->SetStartStringHandler(f, UpbBind(startstr, new uint32_t(num))));
-  ASSERT(h->SetEndStringHandler(f, UpbBind(endstr, new uint32_t(num))));
-  ASSERT(h->SetStringHandler(f, UpbBind(value_string, new uint32_t(num))));
+  if (f.IsSequence()) regseq(h, f, num);
+  ASSERT(h.SetStartStringHandler(f, UpbBind(startstr, new uint32_t(num))));
+  ASSERT(h.SetEndStringHandler(f, UpbBind(endstr, new uint32_t(num))));
+  ASSERT(h.SetStringHandler(f, UpbBind(value_string, new uint32_t(num))));
 }
 
-void AddField(upb_descriptortype_t descriptor_type, const std::string& name,
-              uint32_t fn, bool repeated, upb::MessageDef* md) {
-  // TODO: Fluent interface?  ie.
-  //   ASSERT(md->AddField(upb::BuildFieldDef()
-  //       .SetName("f_message")
-  //       .SetNumber(UPB_DESCRIPTOR_TYPE_MESSAGE)
-  //       .SetDescriptorType(UPB_DESCRIPTOR_TYPE_MESSAGE)
-  //       .SetMessageSubdef(md.get())));
-  upb::reffed_ptr<upb::FieldDef> f = upb::FieldDef::New();
-  ASSERT(f->set_name(name, NULL));
-  ASSERT(f->set_number(fn, NULL));
-  f->set_label(repeated ? UPB_LABEL_REPEATED : UPB_LABEL_OPTIONAL);
-  f->set_descriptor_type(descriptor_type);
-  ASSERT(md->AddField(f.get(), NULL));
-}
-
-void AddFieldsForType(upb_descriptortype_t descriptor_type,
-                      const char* basename, upb::MessageDef* md) {
-  const upb_descriptortype_t t = descriptor_type;
-  AddField(t, std::string("f_") + basename, t, false, md);
-  AddField(t, std::string("r_") + basename, rep_fn(t), true, md);
-}
-
-upb::reffed_ptr<const upb::MessageDef> NewMessageDef() {
-  upb::reffed_ptr<upb::MessageDef> md = upb::MessageDef::New();
-
-  md->set_full_name("DecoderTest", NULL);
-
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_DOUBLE, "double", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_FLOAT, "float", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_INT64, "int64", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_UINT64, "uint64", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_INT32, "int32", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_FIXED64, "fixed64", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_FIXED32, "fixed32", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_BOOL, "bool", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_STRING, "string", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_BYTES, "bytes", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_UINT32, "uint32", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_SFIXED32, "sfixed32", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_SFIXED64, "sfixed64", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_SINT32, "sint32", md.get());
-  AddFieldsForType(UPB_DESCRIPTOR_TYPE_SINT64, "sint64", md.get());
-
-  AddField(UPB_DESCRIPTOR_TYPE_STRING, "nop_field", 40, false, md.get());
-
-  upb::reffed_ptr<upb::FieldDef> f = upb::FieldDef::New();
-  ASSERT(f->set_name("f_message", NULL));
-  ASSERT(f->set_number(UPB_DESCRIPTOR_TYPE_MESSAGE, NULL));
-  f->set_descriptor_type(UPB_DESCRIPTOR_TYPE_MESSAGE);
-  ASSERT(f->set_message_subdef(md.get(), NULL));
-  ASSERT(md->AddField(f.get(), NULL));
-
-  f = upb::FieldDef::New();
-  ASSERT(f->set_name("r_message", NULL));
-  ASSERT(f->set_number(rep_fn(UPB_DESCRIPTOR_TYPE_MESSAGE), NULL));
-  f->set_label(UPB_LABEL_REPEATED);
-  f->set_descriptor_type(UPB_DESCRIPTOR_TYPE_MESSAGE);
-  ASSERT(f->set_message_subdef(md.get(), NULL));
-  ASSERT(md->AddField(f.get(), NULL));
-
-  f = upb::FieldDef::New();
-  ASSERT(f->set_name("f_group", NULL));
-  ASSERT(f->set_number(UPB_DESCRIPTOR_TYPE_GROUP, NULL));
-  f->set_descriptor_type(UPB_DESCRIPTOR_TYPE_GROUP);
-  ASSERT(f->set_message_subdef(md.get(), NULL));
-  ASSERT(md->AddField(f.get(), NULL));
-
-  f = upb::FieldDef::New();
-  ASSERT(f->set_name("r_group", NULL));
-  ASSERT(f->set_number(rep_fn(UPB_DESCRIPTOR_TYPE_GROUP), NULL));
-  f->set_label(UPB_LABEL_REPEATED);
-  f->set_descriptor_type(UPB_DESCRIPTOR_TYPE_GROUP);
-  ASSERT(f->set_message_subdef(md.get(), NULL));
-  ASSERT(md->AddField(f.get(), NULL));
-
-  upb::reffed_ptr<upb::EnumDef> e = upb::EnumDef::New();
-  ASSERT(e->AddValue("FOO", 1, NULL));
-  ASSERT(e->Freeze(NULL));
-
-  f = upb::FieldDef::New();
-  ASSERT(f->set_name("f_enum", NULL));
-  ASSERT(f->set_number(UPB_DESCRIPTOR_TYPE_ENUM, NULL));
-  f->set_descriptor_type(UPB_DESCRIPTOR_TYPE_ENUM);
-  ASSERT(f->set_enum_subdef(e.get(), NULL));
-  ASSERT(md->AddField(f.get(), NULL));
-
-  f = upb::FieldDef::New();
-  ASSERT(f->set_name("r_enum", NULL));
-  ASSERT(f->set_number(rep_fn(UPB_DESCRIPTOR_TYPE_ENUM), NULL));
-  f->set_label(UPB_LABEL_REPEATED);
-  f->set_descriptor_type(UPB_DESCRIPTOR_TYPE_ENUM);
-  ASSERT(f->set_enum_subdef(e.get(), NULL));
-  ASSERT(md->AddField(f.get(), NULL));
-
-  ASSERT(md->Freeze(NULL));
-
-  return md;
-}
-
-upb::reffed_ptr<const upb::Handlers> NewHandlers(TestMode mode) {
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(NewMessageDef().get()));
+struct HandlerRegisterData {
+  TestMode mode;
+};
 
-  if (mode == ALL_HANDLERS) {
-    h->SetStartMessageHandler(UpbMakeHandler(startmsg));
-    h->SetEndMessageHandler(UpbMakeHandler(endmsg));
+void callback(const void *closure, upb::Handlers* h_ptr) {
+  upb::HandlersPtr h(h_ptr);
+  const HandlerRegisterData* data =
+      static_cast<const HandlerRegisterData*>(closure);
+  if (data->mode == ALL_HANDLERS) {
+    h.SetStartMessageHandler(UpbMakeHandler(startmsg));
+    h.SetEndMessageHandler(UpbMakeHandler(endmsg));
 
     // Register handlers for each type.
-    reg<double,   value_double>(h.get(), UPB_DESCRIPTOR_TYPE_DOUBLE);
-    reg<float,    value_float> (h.get(), UPB_DESCRIPTOR_TYPE_FLOAT);
-    reg<int64_t,  value_int64> (h.get(), UPB_DESCRIPTOR_TYPE_INT64);
-    reg<uint64_t, value_uint64>(h.get(), UPB_DESCRIPTOR_TYPE_UINT64);
-    reg<int32_t,  value_int32> (h.get(), UPB_DESCRIPTOR_TYPE_INT32);
-    reg<uint64_t, value_uint64>(h.get(), UPB_DESCRIPTOR_TYPE_FIXED64);
-    reg<uint32_t, value_uint32>(h.get(), UPB_DESCRIPTOR_TYPE_FIXED32);
-    reg<bool,     value_bool>  (h.get(), UPB_DESCRIPTOR_TYPE_BOOL);
-    reg<uint32_t, value_uint32>(h.get(), UPB_DESCRIPTOR_TYPE_UINT32);
-    reg<int32_t,  value_int32> (h.get(), UPB_DESCRIPTOR_TYPE_ENUM);
-    reg<int32_t,  value_int32> (h.get(), UPB_DESCRIPTOR_TYPE_SFIXED32);
-    reg<int64_t,  value_int64> (h.get(), UPB_DESCRIPTOR_TYPE_SFIXED64);
-    reg<int32_t,  value_int32> (h.get(), UPB_DESCRIPTOR_TYPE_SINT32);
-    reg<int64_t,  value_int64> (h.get(), UPB_DESCRIPTOR_TYPE_SINT64);
-
-    reg_str(h.get(), UPB_DESCRIPTOR_TYPE_STRING);
-    reg_str(h.get(), UPB_DESCRIPTOR_TYPE_BYTES);
-    reg_str(h.get(), rep_fn(UPB_DESCRIPTOR_TYPE_STRING));
-    reg_str(h.get(), rep_fn(UPB_DESCRIPTOR_TYPE_BYTES));
+    reg<double,   value_double>(h, UPB_DESCRIPTOR_TYPE_DOUBLE);
+    reg<float,    value_float> (h, UPB_DESCRIPTOR_TYPE_FLOAT);
+    reg<int64_t,  value_int64> (h, UPB_DESCRIPTOR_TYPE_INT64);
+    reg<uint64_t, value_uint64>(h, UPB_DESCRIPTOR_TYPE_UINT64);
+    reg<int32_t,  value_int32> (h, UPB_DESCRIPTOR_TYPE_INT32);
+    reg<uint64_t, value_uint64>(h, UPB_DESCRIPTOR_TYPE_FIXED64);
+    reg<uint32_t, value_uint32>(h, UPB_DESCRIPTOR_TYPE_FIXED32);
+    reg<bool,     value_bool>  (h, UPB_DESCRIPTOR_TYPE_BOOL);
+    reg<uint32_t, value_uint32>(h, UPB_DESCRIPTOR_TYPE_UINT32);
+    reg<int32_t,  value_int32> (h, UPB_DESCRIPTOR_TYPE_ENUM);
+    reg<int32_t,  value_int32> (h, UPB_DESCRIPTOR_TYPE_SFIXED32);
+    reg<int64_t,  value_int64> (h, UPB_DESCRIPTOR_TYPE_SFIXED64);
+    reg<int32_t,  value_int32> (h, UPB_DESCRIPTOR_TYPE_SINT32);
+    reg<int64_t,  value_int64> (h, UPB_DESCRIPTOR_TYPE_SINT64);
+
+    reg_str(h, UPB_DESCRIPTOR_TYPE_STRING);
+    reg_str(h, UPB_DESCRIPTOR_TYPE_BYTES);
+    reg_str(h, rep_fn(UPB_DESCRIPTOR_TYPE_STRING));
+    reg_str(h, rep_fn(UPB_DESCRIPTOR_TYPE_BYTES));
 
     // Register submessage/group handlers that are self-recursive
     // to this type, eg: message M { optional M m = 1; }
-    reg_subm(h.get(), UPB_DESCRIPTOR_TYPE_MESSAGE);
-    reg_subm(h.get(), rep_fn(UPB_DESCRIPTOR_TYPE_MESSAGE));
-    reg_subm(h.get(), UPB_DESCRIPTOR_TYPE_GROUP);
-    reg_subm(h.get(), rep_fn(UPB_DESCRIPTOR_TYPE_GROUP));
+    reg_subm(h, UPB_DESCRIPTOR_TYPE_MESSAGE);
+    reg_subm(h, rep_fn(UPB_DESCRIPTOR_TYPE_MESSAGE));
+
+    if (h.message_def().full_name() == std::string("DecoderTest")) {
+      reg_subm(h, UPB_DESCRIPTOR_TYPE_GROUP);
+      reg_subm(h, rep_fn(UPB_DESCRIPTOR_TYPE_GROUP));
+    }
 
     // For NOP_FIELD we register no handlers, so we can pad a proto freely without
     // changing the output.
   }
-
-  bool ok = h->Freeze(NULL);
-  ASSERT(ok);
-
-  return h;
 }
 
-
 /* Running of test cases ******************************************************/
 
 const upb::Handlers *global_handlers;
-const upb::pb::DecoderMethod *global_method;
-
-upb::pb::Decoder* CreateDecoder(upb::Environment* env,
-                                const upb::pb::DecoderMethod* method,
-                                upb::Sink* sink) {
-  upb::pb::Decoder *ret = upb::pb::Decoder::Create(env, method, sink);
-  ASSERT(ret != NULL);
-  ret->set_max_nesting(MAX_NESTING);
+upb::pb::DecoderMethodPtr global_method;
+
+upb::pb::DecoderPtr CreateDecoder(upb::Arena* arena,
+                                  upb::pb::DecoderMethodPtr method,
+                                  upb::Sink sink, upb::Status* status) {
+  upb::pb::DecoderPtr ret =
+      upb::pb::DecoderPtr::Create(arena, method, sink, status);
+  ret.set_max_nesting(MAX_NESTING);
   return ret;
 }
 
@@ -570,7 +454,7 @@ uint32_t Hash(const string& proto, const string* expected_output, size_t seam1,
   return hash;
 }
 
-void CheckBytesParsed(const upb::pb::Decoder& decoder, size_t ofs) {
+void CheckBytesParsed(upb::pb::DecoderPtr decoder, size_t ofs) {
   // We can't have parsed more data than the decoder callback is telling us it
   // parsed.
   ASSERT(decoder.BytesParsed() <= ofs);
@@ -582,7 +466,7 @@ void CheckBytesParsed(const upb::pb::Decoder& decoder, size_t ofs) {
 }
 
 static bool parse(VerboseParserEnvironment* env,
-                  const upb::pb::Decoder& decoder, int bytes) {
+                  upb::pb::DecoderPtr decoder, int bytes) {
   CheckBytesParsed(decoder, env->ofs());
   bool ret = env->ParseBuffer(bytes);
   if (ret) {
@@ -592,11 +476,11 @@ static bool parse(VerboseParserEnvironment* env,
   return ret;
 }
 
-void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
+void do_run_decoder(VerboseParserEnvironment* env, upb::pb::DecoderPtr decoder,
                     const string& proto, const string* expected_output,
                     size_t i, size_t j, bool may_skip) {
   env->Reset(proto.c_str(), proto.size(), may_skip, expected_output == NULL);
-  decoder->Reset();
+  decoder.Reset();
 
   testhash = Hash(proto, expected_output, i, j, may_skip);
   if (filter_hash && testhash != filter_hash) return;
@@ -605,8 +489,6 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
 
     if (filter_hash) {
       fprintf(stderr, "RUNNING TEST CASE, hash=%x\n", testhash);
-      fprintf(stderr, "JIT on: %s\n",
-              global_method->is_native() ? "true" : "false");
       fprintf(stderr, "Input (len=%u): ", (unsigned)proto.size());
       PrintBinary(proto);
       fprintf(stderr, "\n");
@@ -625,9 +507,9 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
     }
 
     bool ok = env->Start() &&
-              parse(env, *decoder, i) &&
-              parse(env, *decoder, j - i) &&
-              parse(env, *decoder, -1) &&
+              parse(env, decoder, i) &&
+              parse(env, decoder, j - i) &&
+              parse(env, decoder, -1) &&
               env->End();
 
     ASSERT(env->CheckConsistency());
@@ -655,8 +537,8 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::Decoder* decoder,
 void run_decoder(const string& proto, const string* expected_output) {
   VerboseParserEnvironment env(filter_hash != 0);
   upb::Sink sink(global_handlers, &closures[0]);
-  upb::pb::Decoder *decoder = CreateDecoder(env.env(), global_method, &sink);
-  env.ResetBytesSink(decoder->input());
+  upb::pb::DecoderPtr decoder = CreateDecoder(env.arena(), global_method, sink, env.status());
+  env.ResetBytesSink(decoder.input());
   for (size_t i = 0; i < proto.size(); i++) {
     for (size_t j = i; j < UPB_MIN(proto.size(), i + 5); j++) {
       do_run_decoder(&env, decoder, proto, expected_output, i, j, true);
@@ -971,12 +853,12 @@ void test_valid() {
   if (!filter_hash || filter_hash == testhash) {
     testhash = emptyhash;
     upb::Status status;
-    upb::Environment env;
-    env.ReportErrorsTo(&status);
+    upb::Arena arena;
     upb::Sink sink(global_handlers, &closures[0]);
-    upb::pb::Decoder* decoder = CreateDecoder(&env, global_method, &sink);
+    upb::pb::DecoderPtr decoder =
+        CreateDecoder(&arena, global_method, sink, &status);
     output.clear();
-    bool ok = upb::BufferSource::PutBuffer("", 0, decoder->input());
+    bool ok = upb::PutBuffer(std::string(), decoder.input());
     ASSERT(ok);
     ASSERT(status.ok());
     if (test_mode == ALL_HANDLERS) {
@@ -1224,26 +1106,20 @@ void test_valid() {
   run_decoder(buf, &textbuf);
 }
 
-upb::reffed_ptr<const upb::pb::DecoderMethod> NewMethod(
-    const upb::Handlers* dest_handlers, bool allow_jit) {
-  upb::pb::CodeCache cache;
-  cache.set_allow_jit(allow_jit);
-  return cache.GetDecoderMethod(upb::pb::DecoderMethodOptions(dest_handlers));
-}
+void empty_callback(const void *closure, upb::Handlers* h_ptr) {}
 
-void test_emptyhandlers(bool allowjit) {
+void test_emptyhandlers(upb::SymbolTable* symtab) {
   // Create an empty handlers to make sure that the decoder can handle empty
   // messages.
-  upb::reffed_ptr<upb::MessageDef> md = upb::MessageDef::New();
-  ASSERT(md->set_full_name("Empty", NULL));
-  ASSERT(md->Freeze(NULL));
+  HandlerRegisterData handlerdata;
+  handlerdata.mode = test_mode;
 
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md.get()));
-  bool ok = h->Freeze(NULL);
-  ASSERT(ok);
-upb::reffed_ptr<const upb::pb::DecoderMethod> method =
-      NewMethod(h.get(), allowjit);
-  ASSERT(method.get());
+  upb::HandlerCache handler_cache(empty_callback, &handlerdata);
+  upb::pb::CodeCache pb_code_cache(&handler_cache);
+
+  upb::MessageDefPtr md = upb::MessageDefPtr(Empty_getmsgdef(symtab->ptr()));
+  global_handlers = handler_cache.Get(md);
+  global_method = pb_code_cache.Get(md);
 
   // TODO: also test the case where a message has fields, but the fields are
   // submessage fields and have no handlers. This also results in a decoder
@@ -1263,9 +1139,10 @@ upb::reffed_ptr<const upb::pb::DecoderMethod> method =
   };
   for (int i = 0; testdata[i].data; i++) {
     VerboseParserEnvironment env(filter_hash != 0);
-    upb::Sink sink(method->dest_handlers(), &closures[0]);
-    upb::pb::Decoder* decoder = CreateDecoder(env.env(), method.get(), &sink);
-    env.ResetBytesSink(decoder->input());
+    upb::Sink sink(global_method.dest_handlers(), &closures[0]);
+    upb::pb::DecoderPtr decoder =
+        CreateDecoder(env.arena(), global_method, sink, env.status());
+    env.ResetBytesSink(decoder.input());
     env.Reset(testdata[i].data, testdata[i].length, true, false);
     ASSERT(env.Start());
     ASSERT(env.ParseBuffer(-1));
@@ -1274,30 +1151,23 @@ upb::reffed_ptr<const upb::pb::DecoderMethod> method =
   }
 }
 
-void run_tests(bool use_jit) {
-  upb::reffed_ptr<const upb::pb::DecoderMethod> method;
-  upb::reffed_ptr<const upb::Handlers> handlers;
+void run_tests() {
+  HandlerRegisterData handlerdata;
+  handlerdata.mode = test_mode;
 
-  handlers = NewHandlers(test_mode);
-  global_handlers = handlers.get();
+  upb::SymbolTable symtab;
+  upb::HandlerCache handler_cache(callback, &handlerdata);
+  upb::pb::CodeCache pb_code_cache(&handler_cache);
 
-  method = NewMethod(handlers.get(), use_jit);
-  global_method = method.get();
-  ASSERT(use_jit == global_method->is_native());
+  upb::MessageDefPtr md(DecoderTest_getmsgdef(symtab.ptr()));
+  global_handlers = handler_cache.Get(md);
+  global_method = pb_code_cache.Get(md);
   completed = 0;
 
   test_invalid();
   test_valid();
 
-  test_emptyhandlers(use_jit);
-}
-
-void run_test_suite() {
-  // Test without/with JIT.
-  run_tests(false);
-#ifdef UPB_USE_JIT_X64
-  run_tests(true);
-#endif
+  test_emptyhandlers(&symtab);
 }
 
 extern "C" {
@@ -1309,23 +1179,20 @@ int run_tests(int argc, char *argv[]) {
     closures[i] = i;
   }
 
-  upb::reffed_ptr<const upb::pb::DecoderMethod> method;
-  upb::reffed_ptr<const upb::Handlers> handlers;
-
   // Count tests.
   count = &total;
   total = 0;
   test_mode = COUNT_ONLY;
-  run_test_suite();
+  run_tests();
   count = &completed;
 
   total *= 2;  // NO_HANDLERS, ALL_HANDLERS.
 
   test_mode = NO_HANDLERS;
-  run_test_suite();
+  run_tests();
 
   test_mode = ALL_HANDLERS;
-  run_test_suite();
+  run_tests();
 
   printf("All tests passed, %d assertions.\n", num_assertions);
   return 0;
diff --git a/tests/pb/test_decoder.proto b/tests/pb/test_decoder.proto
new file mode 100644
index 0000000..e9fa6ad
--- /dev/null
+++ b/tests/pb/test_decoder.proto
@@ -0,0 +1,128 @@
+
+syntax = "proto2";
+
+enum TestEnum {
+  FOO = 1;
+}
+
+message Empty {}
+
+message DecoderTest {
+  optional double      f_double   = 1;
+  optional float       f_float    = 2;
+  optional int64       f_int64    = 3;
+  optional uint64      f_uint64   = 4;
+  optional int32       f_int32    = 5;
+  optional fixed64     f_fixed64  = 6;
+  optional fixed32     f_fixed32  = 7;
+  optional bool        f_bool     = 8;
+  optional string      f_string   = 9;
+  optional DecoderTest f_message  = 11;
+  optional bytes       f_bytes    = 12;
+  optional uint32      f_uint32   = 13;
+  optional TestEnum    f_enum     = 14;
+  optional sfixed32    f_sfixed32 = 15;
+  optional sfixed64    f_sfixed64 = 16;
+  optional sint32      f_sint32   = 17;
+  optional sint64      f_sint64   = 18;
+
+  optional string      nop_field  = 40;
+
+  repeated double      r_double   = 536869912;
+  repeated float       r_float    = 536869913;
+  repeated int64       r_int64    = 536869914;
+  repeated uint64      r_uint64   = 536869915;
+  repeated int32       r_int32    = 536869916;
+  repeated fixed64     r_fixed64  = 536869917;
+  repeated fixed32     r_fixed32  = 536869918;
+  repeated bool        r_bool     = 536869919;
+  repeated string      r_string   = 536869920;
+  repeated DecoderTest r_message  = 536869922;
+  repeated bytes       r_bytes    = 536869923;
+  repeated uint32      r_uint32   = 536869924;
+  repeated TestEnum    r_enum     = 536869925;
+  repeated sfixed32    r_sfixed32 = 536869926;
+  repeated sfixed64    r_sfixed64 = 536869927;
+  repeated sint32      r_sint32   = 536869928;
+  repeated sint64      r_sint64   = 536869929;
+
+  optional group F_group = 10 {
+    optional double      f_double   = 1;
+    optional float       f_float    = 2;
+    optional int64       f_int64    = 3;
+    optional uint64      f_uint64   = 4;
+    optional int32       f_int32    = 5;
+    optional fixed64     f_fixed64  = 6;
+    optional fixed32     f_fixed32  = 7;
+    optional bool        f_bool     = 8;
+    optional string      f_string   = 9;
+    optional DecoderTest f_message  = 11;
+    optional bytes       f_bytes    = 12;
+    optional uint32      f_uint32   = 13;
+    optional TestEnum    f_enum     = 14;
+    optional sfixed32    f_sfixed32 = 15;
+    optional sfixed64    f_sfixed64 = 16;
+    optional sint32      f_sint32   = 17;
+    optional sint64      f_sint64   = 18;
+
+    optional string      nop_field  = 40;
+
+    repeated double      r_double   = 536869912;
+    repeated float       r_float    = 536869913;
+    repeated int64       r_int64    = 536869914;
+    repeated uint64      r_uint64   = 536869915;
+    repeated int32       r_int32    = 536869916;
+    repeated fixed64     r_fixed64  = 536869917;
+    repeated fixed32     r_fixed32  = 536869918;
+    repeated bool        r_bool     = 536869919;
+    repeated string      r_string   = 536869920;
+    repeated DecoderTest r_message  = 536869922;
+    repeated bytes       r_bytes    = 536869923;
+    repeated uint32      r_uint32   = 536869924;
+    repeated TestEnum    r_enum     = 536869925;
+    repeated sfixed32    r_sfixed32 = 536869926;
+    repeated sfixed64    r_sfixed64 = 536869927;
+    repeated sint32      r_sint32   = 536869928;
+    repeated sint64      r_sint64   = 536869929;
+  }
+
+  optional group R_group = 536869921 {
+    optional double      f_double   = 1;
+    optional float       f_float    = 2;
+    optional int64       f_int64    = 3;
+    optional uint64      f_uint64   = 4;
+    optional int32       f_int32    = 5;
+    optional fixed64     f_fixed64  = 6;
+    optional fixed32     f_fixed32  = 7;
+    optional bool        f_bool     = 8;
+    optional string      f_string   = 9;
+    optional DecoderTest f_message  = 11;
+    optional bytes       f_bytes    = 12;
+    optional uint32      f_uint32   = 13;
+    optional TestEnum    f_enum     = 14;
+    optional sfixed32    f_sfixed32 = 15;
+    optional sfixed64    f_sfixed64 = 16;
+    optional sint32      f_sint32   = 17;
+    optional sint64      f_sint64   = 18;
+
+    optional string      nop_field  = 40;
+
+    repeated double      r_double   = 536869912;
+    repeated float       r_float    = 536869913;
+    repeated int64       r_int64    = 536869914;
+    repeated uint64      r_uint64   = 536869915;
+    repeated int32       r_int32    = 536869916;
+    repeated fixed64     r_fixed64  = 536869917;
+    repeated fixed32     r_fixed32  = 536869918;
+    repeated bool        r_bool     = 536869919;
+    repeated string      r_string   = 536869920;
+    repeated DecoderTest r_message  = 536869922;
+    repeated bytes       r_bytes    = 536869923;
+    repeated uint32      r_uint32   = 536869924;
+    repeated TestEnum    r_enum     = 536869925;
+    repeated sfixed32    r_sfixed32 = 536869926;
+    repeated sfixed64    r_sfixed64 = 536869927;
+    repeated sint32      r_sint32   = 536869928;
+    repeated sint64      r_sint64   = 536869929;
+  }
+}
diff --git a/tests/pb/test_encoder.cc b/tests/pb/test_encoder.cc
index 6c20e27..aa33370 100644
--- a/tests/pb/test_encoder.cc
+++ b/tests/pb/test_encoder.cc
@@ -2,10 +2,9 @@
 #include "tests/test_util.h"
 #include "tests/upb_test.h"
 #include "upb/bindings/stdc++/string.h"
-#include "upb/descriptor/descriptor.upbdefs.h"
+#include "google/protobuf/descriptor.upb.h"
 #include "upb/pb/decoder.h"
 #include "upb/pb/encoder.h"
-#include "upb/pb/glue.h"
 
 std::string read_string(const char *filename) {
   size_t len;
@@ -18,24 +17,39 @@ std::string read_string(const char *filename) {
 }
 
 void test_pb_roundtrip() {
-  upb::reffed_ptr<const upb::MessageDef> md(
-      upbdefs::google::protobuf::FileDescriptorSet::get());
-  upb::reffed_ptr<const upb::Handlers> encoder_handlers(
-      upb::pb::Encoder::NewHandlers(md.get()));
-  upb::reffed_ptr<const upb::pb::DecoderMethod> method(
-      upb::pb::DecoderMethod::New(
-          upb::pb::DecoderMethodOptions(encoder_handlers.get())));
+  std::string input = read_string("google/protobuf/descriptor.pb");
+  upb::SymbolTable symtab;
+  upb::HandlerCache encoder_cache(upb::pb::EncoderPtr::NewCache());
+  upb::pb::CodeCache decoder_cache(&encoder_cache);
+  upb::Arena arena;
+  google_protobuf_FileDescriptorSet *set =
+      google_protobuf_FileDescriptorSet_parse(input.c_str(), input.size(),
+                                              arena.ptr());
+  ASSERT(set);
+  size_t n;
+  const google_protobuf_FileDescriptorProto *const *files =
+      google_protobuf_FileDescriptorSet_file(set, &n);
+  ASSERT(n == 1);
+  upb::Status status;
+  upb::FileDefPtr file_def = symtab.AddFile(files[0], &status);
+  if (!file_def) {
+    fprintf(stderr, "Error building def: %s\n", status.error_message());
+    ASSERT(false);
+  }
+  upb::MessageDefPtr md =
+      symtab.LookupMessage("google.protobuf.FileDescriptorSet");
+  ASSERT(md);
+  const upb::Handlers *encoder_handlers = encoder_cache.Get(md);
+  ASSERT(encoder_handlers);
+  const upb::pb::DecoderMethodPtr method = decoder_cache.Get(md);
 
-  upb::InlinedEnvironment<512> env;
-  std::string input = read_string("upb/descriptor/descriptor.pb");
   std::string output;
   upb::StringSink string_sink(&output);
-  upb::pb::Encoder* encoder =
-      upb::pb::Encoder::Create(&env, encoder_handlers.get(),
-                               string_sink.input());
-  upb::pb::Decoder* decoder =
-      upb::pb::Decoder::Create(&env, method.get(), encoder->input());
-  bool ok = upb::BufferSource::PutBuffer(input, decoder->input());
+  upb::pb::EncoderPtr encoder =
+      upb::pb::EncoderPtr::Create(&arena, encoder_handlers, string_sink.input());
+  upb::pb::DecoderPtr decoder =
+      upb::pb::DecoderPtr::Create(&arena, method, encoder.input(), &status);
+  bool ok = upb::PutBuffer(input, decoder.input());
   ASSERT(ok);
   ASSERT(input == output);
 }
diff --git a/tests/pb/test_varint.c b/tests/pb/test_varint.c
index f77eebd..7b2fe41 100644
--- a/tests/pb/test_varint.c
+++ b/tests/pb/test_varint.c
@@ -20,6 +20,25 @@ static void test_varint_for_num(upb_decoderet (*decoder)(const char*),
 
     memset(buf2, 0, sizeof(buf2));
     memcpy(&buf2, &encoded, 8);
+#ifdef UPB_BIG_ENDIAN
+    char swap[8];
+    swap[0] = buf2[7];
+    swap[1] = buf2[6];
+    swap[2] = buf2[5];
+    swap[3] = buf2[4];
+    swap[4] = buf2[3];
+    swap[5] = buf2[2];
+    swap[6] = buf2[1];
+    swap[7] = buf2[0];
+    buf2[0] = swap[0];
+    buf2[1] = swap[1];
+    buf2[2] = swap[2];
+    buf2[3] = swap[3];
+    buf2[4] = swap[4];
+    buf2[5] = swap[5];
+    buf2[6] = swap[6];
+    buf2[7] = swap[7];
+#endif    
     r = decoder(buf2);
     ASSERT(r.val == num);
     ASSERT(r.p == buf2 + upb_value_size(encoded));
diff --git a/tests/test_cpp.cc b/tests/test_cpp.cc
index 2cd9802..ed8e9c4 100644
--- a/tests/test_cpp.cc
+++ b/tests/test_cpp.cc
@@ -11,13 +11,13 @@
 #include <set>
 #include <sstream>
 
+#include "tests/test_cpp.upbdefs.h"
 #include "upb/def.h"
-#include "upb/descriptor/reader.h"
 #include "upb/handlers.h"
 #include "upb/pb/decoder.h"
-#include "upb/pb/glue.h"
-#include "upb_test.h"
+#include "upb/pb/textprinter.h"
 #include "upb/upb.h"
+#include "upb_test.h"
 
 template <class T>
 void AssertInsert(T* const container, const typename T::value_type& val) {
@@ -25,182 +25,6 @@ void AssertInsert(T* const container, const typename T::value_type& val) {
   ASSERT(inserted);
 }
 
-static void TestCastsUpDown() {
-  upb::reffed_ptr<const upb::MessageDef> reffed_md(upb::MessageDef::New());
-  const upb::MessageDef* md = reffed_md.get();
-
-  // Upcast to reffed_ptr implicitly.
-  upb::reffed_ptr<const upb::Def> reffed_def = reffed_md;
-  ASSERT(reffed_def.get() == upb::upcast(reffed_md.get()));
-
-  // Upcast to raw pointer must be explicit.
-  const upb::Def* def = upb::upcast(md);
-  ASSERT(def == reffed_def.get());
-  const upb::Def* def2 = upb::upcast(reffed_md.get());
-  ASSERT(def2 == reffed_def.get());
-
-  // Downcast/dyncast of raw pointer uses upb::down_cast/upb::dyn_cast.
-  const upb::MessageDef* md2 = upb::down_cast<const upb::MessageDef*>(def);
-  const upb::MessageDef* md3 = upb::dyn_cast<const upb::MessageDef*>(def);
-  ASSERT(md == md2);
-  ASSERT(md == md3);
-
-  // Downcast/dyncast of reffed_ptr uses down_cast/dyn_cast members.
-  upb::reffed_ptr<const upb::MessageDef> md4(
-      reffed_def.down_cast<const upb::MessageDef>());
-  upb::reffed_ptr<const upb::MessageDef> md5(
-      reffed_def.dyn_cast<const upb::MessageDef>());
-  ASSERT(md == md4.get());
-  ASSERT(md == md5.get());
-
-  // Failed dyncast returns NULL.
-  ASSERT(upb::dyn_cast<const upb::EnumDef*>(def) == NULL);
-  ASSERT(reffed_def.dyn_cast<const upb::EnumDef>().get() == NULL);
-}
-
-static void TestCastsConst0() {
-  // Should clean up properly even if it is not assigned to anything.
-  upb::MessageDef::New();
-}
-
-static void TestCastsConst1() {
-  // Test reffed mutable -> reffed mutable construction/assignment.
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::MessageDef *md2 = md.get();
-  md = upb::MessageDef::New();
-  ASSERT(md.get());
-  ASSERT(md.get() != md2);
-}
-
-static void TestCastsConst2() {
-  // Test reffed mutable -> reffed mutable upcast construction/assignment.
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::reffed_ptr<upb::Def> def = md;
-  ASSERT(upb::upcast(md.get()) == def.get());
-  def = md;
-  ASSERT(upb::upcast(md.get()) == def.get());
-}
-
-static void TestCastsConst3() {
-  // Test reffed mutable -> reffed mutable downcast.
-  upb::reffed_ptr<upb::Def> def(upb::MessageDef::New());
-  upb::reffed_ptr<upb::MessageDef> md = def.down_cast<upb::MessageDef>();
-  ASSERT(upb::upcast(md.get()) == def.get());
-}
-
-static void TestCastsConst4() {
-  // Test reffed mutable -> reffed mutable dyncast.
-  upb::reffed_ptr<upb::Def> def(upb::MessageDef::New());
-  upb::reffed_ptr<upb::MessageDef> md = def.dyn_cast<upb::MessageDef>();
-  ASSERT(upb::upcast(md.get()) == def.get());
-}
-
-static void TestCastsConst5() {
-  // Test reffed mutable -> reffed const construction/assignment.
-  upb::reffed_ptr<const upb::MessageDef> md(upb::MessageDef::New());
-  const upb::MessageDef *md2 = md.get();
-  md = upb::MessageDef::New();
-  ASSERT(md.get());
-  ASSERT(md.get() != md2);
-}
-
-static void TestCastsConst6() {
-  // Test reffed mutable -> reffed const upcast construction/assignment.
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::reffed_ptr<const upb::Def> def = md;
-  ASSERT(upb::upcast(md.get()) == def.get());
-  def = md;
-  ASSERT(upb::upcast(md.get()) == def.get());
-}
-
-static void TestCastsConst7() {
-  // Test reffed mutable -> reffed const downcast.
-  upb::reffed_ptr<upb::Def> def(upb::MessageDef::New());
-  upb::reffed_ptr<const upb::MessageDef> md =
-      def.down_cast<const upb::MessageDef>();
-  ASSERT(upb::upcast(md.get()) == def.get());
-}
-
-static void TestCastsConst8() {
-  // Test reffed mutable -> reffed const dyncast.
-  upb::reffed_ptr<upb::Def> def(upb::MessageDef::New());
-  upb::reffed_ptr<const upb::MessageDef> md =
-      def.dyn_cast<const upb::MessageDef>();
-  ASSERT(upb::upcast(md.get()) == def.get());
-}
-
-static void TestCastsConst9() {
-  // Test plain mutable -> plain mutable upcast
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::Def* def = upb::upcast(md.get());
-  ASSERT(upb::down_cast<upb::MessageDef*>(def) == md.get());
-}
-
-static void TestCastsConst10() {
-  // Test plain const -> plain const upcast
-  upb::reffed_ptr<const upb::MessageDef> md(upb::MessageDef::New());
-  const upb::Def* def = upb::upcast(md.get());
-  ASSERT(upb::down_cast<const upb::MessageDef*>(def) == md.get());
-}
-
-static void TestSymbolTable(const char *descriptor_file) {
-  upb::Status status;
-  std::ifstream file_in(descriptor_file, std::ios::binary);
-  std::string descriptor((std::istreambuf_iterator<char>(file_in)),
-                         (std::istreambuf_iterator<char>()));
-  std::vector<upb::reffed_ptr<upb::FileDef> > files;
-  if (!upb::LoadDescriptor(descriptor, &status, &files)) {
-    std::cerr << "Couldn't load descriptor: " << status.error_message();
-    exit(1);
-  }
-
-  upb::SymbolTable* s = upb::SymbolTable::New();
-
-  for (size_t i = 0; i < files.size(); i++) {
-    ASSERT(s->AddFile(files[i].get(), &status));
-  }
-
-  upb::reffed_ptr<const upb::MessageDef> md(s->LookupMessage("C"));
-  ASSERT(md.get());
-
-  // We want a def that satisfies this to test iteration.
-  ASSERT(md->field_count() > 1);
-
-#ifdef UPB_CXX11
-  // Test range-based for.
-  std::set<const upb::FieldDef*> fielddefs;
-  for (const upb::FieldDef* f : md.get()->fields()) {
-    AssertInsert(&fielddefs, f);
-    ASSERT(f->containing_type() == md.get());
-  }
-  ASSERT(fielddefs.size() == md->field_count());
-#endif
-
-  ASSERT(md.get());
-  upb::SymbolTable::Free(s);
-}
-
-static void TestCasts1() {
-  upb::reffed_ptr<const upb::MessageDef> md(upb::MessageDef::New());
-  const upb::Def* def = upb::upcast(md.get());
-  const upb::MessageDef* md2 = upb::down_cast<const upb::MessageDef*>(def);
-  const upb::MessageDef* md3 = upb::dyn_cast<const upb::MessageDef*>(def);
-
-  ASSERT(md.get() == md2);
-  ASSERT(md.get() == md3);
-
-  const upb::EnumDef* ed = upb::dyn_cast<const upb::EnumDef*>(def);
-  ASSERT(!ed);
-}
-
-static void TestCasts2() {
-  // Test mutable -> const cast.
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::Def* def = upb::upcast(md.get());
-  const upb::MessageDef* const_md = upb::down_cast<const upb::MessageDef*>(def);
-  ASSERT(const_md == md.get());
-}
-
 //
 // Tests for registering and calling handlers in all their variants.
 // This test code is very repetitive because we have to declare each
@@ -225,20 +49,20 @@ static const int kExpectedHandlerData = 1232323;
 
 class StringBufTesterBase {
  public:
-  static const upb::FieldDef::Type kFieldType = UPB_TYPE_STRING;
+  static const int kFieldNumber = 3;
 
   StringBufTesterBase() : seen_(false), handler_data_val_(0) {}
 
-  void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) {
-    upb::Handlers::Selector start;
-    ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_STARTSTR, &start));
-    upb::Handlers::Selector str;
-    ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_STRING, &str));
+  void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) {
+    upb_selector_t start;
+    ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_STARTSTR, &start));
+    upb_selector_t str;
+    ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_STRING, &str));
 
     ASSERT(!seen_);
     upb::Sink sub;
-    sink->StartMessage();
-    sink->StartString(start, 0, &sub);
+    sink.StartMessage();
+    sink.StartString(start, 0, &sub);
     size_t ret = sub.PutStringBuffer(str, &buf_, 5, &handle_);
     ASSERT(seen_);
     ASSERT(len_ == 5);
@@ -251,7 +75,7 @@ class StringBufTesterBase {
   int handler_data_val_;
   size_t len_;
   char buf_;
-  upb::BufferHandle handle_;
+  upb_bufhandle handle_;
 };
 
 // Test 8 combinations of:
@@ -268,9 +92,9 @@ class StringBufTesterVoidMethodNoHandlerDataNoHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidMethodNoHandlerDataNoHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -286,14 +110,14 @@ class StringBufTesterVoidMethodNoHandlerDataWithHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidMethodNoHandlerDataWithHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
  private:
-  void Handler(const char *buf, size_t len, const upb::BufferHandle* handle) {
+  void Handler(const char *buf, size_t len, const upb_bufhandle* handle) {
     ASSERT(buf == &buf_);
     ASSERT(handle == &handle_);
     seen_ = true;
@@ -305,9 +129,9 @@ class StringBufTesterVoidMethodWithHandlerDataNoHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidMethodWithHandlerDataNoHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(
+    ASSERT(h.SetStringHandler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -324,15 +148,15 @@ class StringBufTesterVoidMethodWithHandlerDataWithHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidMethodWithHandlerDataWithHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(
+    ASSERT(h.SetStringHandler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
  private:
   void Handler(const int* hd, const char* buf, size_t len,
-               const upb::BufferHandle* handle) {
+               const upb_bufhandle* handle) {
     ASSERT(buf == &buf_);
     ASSERT(handle == &handle_);
     handler_data_val_ = *hd;
@@ -345,9 +169,9 @@ class StringBufTesterVoidFunctionNoHandlerDataNoHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidFunctionNoHandlerDataNoHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -363,15 +187,15 @@ class StringBufTesterVoidFunctionNoHandlerDataWithHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidFunctionNoHandlerDataWithHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
  private:
   static void Handler(ME* t, const char* buf, size_t len,
-                      const upb::BufferHandle* handle) {
+                      const upb_bufhandle* handle) {
     ASSERT(buf == &t->buf_);
     ASSERT(handle == &t->handle_);
     t->seen_ = true;
@@ -383,9 +207,9 @@ class StringBufTesterVoidFunctionWithHandlerDataNoHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidFunctionWithHandlerDataNoHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(
+    ASSERT(h.SetStringHandler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -402,15 +226,15 @@ class StringBufTesterVoidFunctionWithHandlerDataWithHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterVoidFunctionWithHandlerDataWithHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(
+    ASSERT(h.SetStringHandler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
  private:
   static void Handler(ME* t, const int* hd, const char* buf, size_t len,
-                      const upb::BufferHandle* handle) {
+                      const upb_bufhandle* handle) {
     ASSERT(buf == &t->buf_);
     ASSERT(handle == &t->handle_);
     t->handler_data_val_ = *hd;
@@ -423,9 +247,9 @@ class StringBufTesterSizeTMethodNoHandlerDataNoHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterSizeTMethodNoHandlerDataNoHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -442,9 +266,9 @@ class StringBufTesterBoolMethodNoHandlerDataNoHandle
     : public StringBufTesterBase {
  public:
   typedef StringBufTesterBoolMethodNoHandlerDataNoHandle ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -461,14 +285,14 @@ class StartMsgTesterBase {
  public:
   // We don't need the FieldDef it will create, but the test harness still
   // requires that we provide one.
-  static const upb::FieldDef::Type kFieldType = UPB_TYPE_STRING;
+  static const int kFieldNumber = 3;
 
   StartMsgTesterBase() : seen_(false), handler_data_val_(0) {}
 
-  void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) {
+  void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
     ASSERT(!seen_);
-    sink->StartMessage();
+    sink.StartMessage();
     ASSERT(seen_);
     ASSERT(handler_data_val_ == kExpectedHandlerData);
   }
@@ -484,9 +308,9 @@ class StartMsgTesterBase {
 class StartMsgTesterVoidFunctionNoHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterVoidFunctionNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&Handler)));
+    ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -500,9 +324,9 @@ class StartMsgTesterVoidFunctionNoHandlerData : public StartMsgTesterBase {
 class StartMsgTesterBoolFunctionNoHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterBoolFunctionNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&Handler)));
+    ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -516,9 +340,9 @@ class StartMsgTesterBoolFunctionNoHandlerData : public StartMsgTesterBase {
 class StartMsgTesterVoidMethodNoHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterVoidMethodNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -531,9 +355,9 @@ class StartMsgTesterVoidMethodNoHandlerData : public StartMsgTesterBase {
 class StartMsgTesterBoolMethodNoHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterBoolMethodNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -547,9 +371,9 @@ class StartMsgTesterBoolMethodNoHandlerData : public StartMsgTesterBase {
 class StartMsgTesterVoidFunctionWithHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterVoidFunctionWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(
+    ASSERT(h.SetStartMessageHandler(
         UpbBind(&Handler, new int(kExpectedHandlerData))));
   }
 
@@ -563,9 +387,9 @@ class StartMsgTesterVoidFunctionWithHandlerData : public StartMsgTesterBase {
 class StartMsgTesterBoolFunctionWithHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterBoolFunctionWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(
+    ASSERT(h.SetStartMessageHandler(
         UpbBind(&Handler, new int(kExpectedHandlerData))));
   }
 
@@ -580,9 +404,9 @@ class StartMsgTesterBoolFunctionWithHandlerData : public StartMsgTesterBase {
 class StartMsgTesterVoidMethodWithHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterVoidMethodWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(
+    ASSERT(h.SetStartMessageHandler(
         UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -596,9 +420,9 @@ class StartMsgTesterVoidMethodWithHandlerData : public StartMsgTesterBase {
 class StartMsgTesterBoolMethodWithHandlerData : public StartMsgTesterBase {
  public:
   typedef StartMsgTesterBoolMethodWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
     UPB_UNUSED(f);
-    ASSERT(h->SetStartMessageHandler(
+    ASSERT(h.SetStartMessageHandler(
         UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -612,16 +436,16 @@ class StartMsgTesterBoolMethodWithHandlerData : public StartMsgTesterBase {
 
 class Int32ValueTesterBase {
  public:
-  static const upb::FieldDef::Type kFieldType = UPB_TYPE_INT32;
+  static const int kFieldNumber = 1;
 
   Int32ValueTesterBase() : seen_(false), val_(0), handler_data_val_(0) {}
 
-  void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) {
-    upb::Handlers::Selector s;
-    ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_INT32, &s));
+  void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) {
+    upb_selector_t s;
+    ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_INT32, &s));
 
     ASSERT(!seen_);
-    sink->PutInt32(s, 5);
+    sink.PutInt32(s, 5);
     ASSERT(seen_);
     ASSERT(handler_data_val_ == kExpectedHandlerData);
     ASSERT(val_ == 5);
@@ -640,8 +464,8 @@ class ValueTesterInt32VoidFunctionNoHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidFunctionNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler)));
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -656,8 +480,8 @@ class ValueTesterInt32BoolFunctionNoHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolFunctionNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler)));
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -672,8 +496,8 @@ class ValueTesterInt32BoolFunctionNoHandlerData
 class ValueTesterInt32VoidMethodNoHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidMethodNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -687,8 +511,8 @@ class ValueTesterInt32VoidMethodNoHandlerData : public Int32ValueTesterBase {
 class ValueTesterInt32BoolMethodNoHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolMethodNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -704,8 +528,8 @@ class ValueTesterInt32VoidFunctionWithHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidFunctionWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&Handler, new int(kExpectedHandlerData))));
   }
 
@@ -721,8 +545,8 @@ class ValueTesterInt32BoolFunctionWithHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolFunctionWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&Handler, new int(kExpectedHandlerData))));
   }
 
@@ -738,8 +562,8 @@ class ValueTesterInt32BoolFunctionWithHandlerData
 class ValueTesterInt32VoidMethodWithHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidMethodWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -754,8 +578,8 @@ class ValueTesterInt32VoidMethodWithHandlerData : public Int32ValueTesterBase {
 class ValueTesterInt32BoolMethodWithHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolMethodWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
-    ASSERT(h->SetInt32Handler(
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -769,22 +593,28 @@ class ValueTesterInt32BoolMethodWithHandlerData : public Int32ValueTesterBase {
 };
 
 template <class T>
+void RegisterHandlers(const void* closure, upb::Handlers* h_ptr) {
+  T* tester = const_cast<T*>(static_cast<const T*>(closure));
+  upb::HandlersPtr h(h_ptr);
+  upb::FieldDefPtr f = h.message_def().FindFieldByNumber(T::kFieldNumber);
+  ASSERT(f);
+  tester->Register(h, f);
+}
+
+template <class T>
 void TestHandler() {
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::reffed_ptr<upb::FieldDef> f(upb::FieldDef::New());
-  f->set_type(T::kFieldType);
-  ASSERT(f->set_name("test", NULL));
-  ASSERT(f->set_number(1, NULL));
-  ASSERT(md->AddField(f, NULL));
-  ASSERT(md->Freeze(NULL));
-
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md.get()));
   T tester;
-  tester.Register(h.get(), f.get());
-  ASSERT(h->Freeze(NULL));
+  upb::SymbolTable symtab;
+  upb::HandlerCache cache(&RegisterHandlers<T>, &tester);
+  upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr()));
+  ASSERT(md);
+  upb::FieldDefPtr f = md.FindFieldByNumber(T::kFieldNumber);
+  ASSERT(f);
 
-  upb::Sink sink(h.get(), &tester);
-  tester.CallAndVerify(&sink, f.get());
+  const upb::Handlers* h = cache.Get(md);
+
+  upb::Sink sink(h, &tester);
+  tester.CallAndVerify(sink, f);
 }
 
 class T1 {};
@@ -843,247 +673,186 @@ void DoNothingStringBufHandler(C* closure, const char *buf, size_t len) {
 }
 
 template <class C>
-void DoNothingEndMessageHandler(C* closure, upb::Status *status) {
+void DoNothingEndMessageHandler(C* closure, upb_status *status) {
   UPB_UNUSED(closure);
   UPB_UNUSED(status);
 }
 
-void TestMismatchedTypes() {
-  // First create a schema for our test.
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-
-  upb::reffed_ptr<upb::FieldDef> f(upb::FieldDef::New());
-  f->set_type(UPB_TYPE_INT32);
-  ASSERT(f->set_name("i32", NULL));
-  ASSERT(f->set_number(1, NULL));
-  ASSERT(md->AddField(f, NULL));
-  const upb::FieldDef* i32 = f.get();
-
-  f = upb::FieldDef::New();
-  f->set_type(UPB_TYPE_INT32);
-  ASSERT(f->set_name("r_i32", NULL));
-  ASSERT(f->set_number(2, NULL));
-  f->set_label(UPB_LABEL_REPEATED);
-  ASSERT(md->AddField(f, NULL));
-  const upb::FieldDef* r_i32 = f.get();
-
-  f = upb::FieldDef::New();
-  f->set_type(UPB_TYPE_STRING);
-  ASSERT(f->set_name("str", NULL));
-  ASSERT(f->set_number(3, NULL));
-  ASSERT(md->AddField(f, NULL));
-  const upb::FieldDef* str = f.get();
-
-  f = upb::FieldDef::New();
-  f->set_type(UPB_TYPE_STRING);
-  ASSERT(f->set_name("r_str", NULL));
-  ASSERT(f->set_number(4, NULL));
-  f->set_label(UPB_LABEL_REPEATED);
-  ASSERT(md->AddField(f, NULL));
-  const upb::FieldDef* r_str = f.get();
-
-  f = upb::FieldDef::New();
-  f->set_type(UPB_TYPE_MESSAGE);
-  ASSERT(f->set_name("msg", NULL));
-  ASSERT(f->set_number(5, NULL));
-  ASSERT(f->set_message_subdef(md.get(), NULL));
-  ASSERT(md->AddField(f, NULL));
-  const upb::FieldDef* msg = f.get();
-
-  f = upb::FieldDef::New();
-  f->set_type(UPB_TYPE_MESSAGE);
-  ASSERT(f->set_name("r_msg", NULL));
-  ASSERT(f->set_number(6, NULL));
-  ASSERT(f->set_message_subdef(md.get(), NULL));
-  f->set_label(UPB_LABEL_REPEATED);
-  ASSERT(md->AddField(f, NULL));
-  const upb::FieldDef* r_msg = f.get();
-
-  ASSERT(md->Freeze(NULL));
-
-  // Now test the type-checking in handler registration.
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md.get()));
+void RegisterMismatchedTypes(const void* closure, upb::Handlers* h_ptr) {
+  upb::HandlersPtr h(h_ptr);
+
+  upb::MessageDefPtr md(h.message_def());
+  ASSERT(md);
+  upb::FieldDefPtr i32 = md.FindFieldByName("i32");
+  upb::FieldDefPtr r_i32 = md.FindFieldByName("r_i32");
+  upb::FieldDefPtr str = md.FindFieldByName("str");
+  upb::FieldDefPtr r_str = md.FindFieldByName("r_str");
+  upb::FieldDefPtr msg = md.FindFieldByName("msg");
+  upb::FieldDefPtr r_msg = md.FindFieldByName("r_msg");
+  ASSERT(i32);
+  ASSERT(r_i32);
+  ASSERT(str);
+  ASSERT(r_str);
+  ASSERT(msg);
+  ASSERT(r_msg);
 
   // Establish T1 as the top-level closure type.
-  ASSERT(h->SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
+  ASSERT(h.SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
 
   // Now any other attempt to set another handler with T2 as the top-level
   // closure should fail.  But setting these same handlers with T1 as the
   // top-level closure will succeed.
-  ASSERT(!h->SetStartMessageHandler(UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetStartMessageHandler(UpbMakeHandler(DoNothingHandler<T1>)));
+  ASSERT(!h.SetStartMessageHandler(UpbMakeHandler(DoNothingHandler<T2>)));
+  ASSERT(h.SetStartMessageHandler(UpbMakeHandler(DoNothingHandler<T1>)));
 
   ASSERT(
-      !h->SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler<T2>)));
+      !h.SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler<T2>)));
   ASSERT(
-      h->SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler<T1>)));
+      h.SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler<T1>)));
 
-  ASSERT(!h->SetStartStringHandler(
+  ASSERT(!h.SetStartStringHandler(
               str, UpbMakeHandler(DoNothingStartHandler<T1>::String<T2>)));
-  ASSERT(h->SetStartStringHandler(
+  ASSERT(h.SetStartStringHandler(
               str, UpbMakeHandler(DoNothingStartHandler<T1>::String<T1>)));
 
-  ASSERT(!h->SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler<T1>)));
+  ASSERT(!h.SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler<T2>)));
+  ASSERT(h.SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler<T1>)));
 
-  ASSERT(!h->SetStartSubMessageHandler(
+  ASSERT(!h.SetStartSubMessageHandler(
               msg, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T2>)));
-  ASSERT(h->SetStartSubMessageHandler(
+  ASSERT(h.SetStartSubMessageHandler(
               msg, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T1>)));
 
   ASSERT(
-      !h->SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler<T2>)));
+      !h.SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler<T2>)));
   ASSERT(
-      h->SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler<T1>)));
+      h.SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler<T1>)));
 
-  ASSERT(!h->SetStartSequenceHandler(
+  ASSERT(!h.SetStartSequenceHandler(
               r_i32, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T2>)));
-  ASSERT(h->SetStartSequenceHandler(
+  ASSERT(h.SetStartSequenceHandler(
               r_i32, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T1>)));
 
-  ASSERT(!h->SetEndSequenceHandler(
+  ASSERT(!h.SetEndSequenceHandler(
               r_i32, UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetEndSequenceHandler(
+  ASSERT(h.SetEndSequenceHandler(
               r_i32, UpbMakeHandler(DoNothingHandler<T1>)));
 
-  ASSERT(!h->SetStartSequenceHandler(
+  ASSERT(!h.SetStartSequenceHandler(
               r_msg, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T2>)));
-  ASSERT(h->SetStartSequenceHandler(
+  ASSERT(h.SetStartSequenceHandler(
               r_msg, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T1>)));
 
-  ASSERT(!h->SetEndSequenceHandler(
+  ASSERT(!h.SetEndSequenceHandler(
               r_msg, UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetEndSequenceHandler(
+  ASSERT(h.SetEndSequenceHandler(
               r_msg, UpbMakeHandler(DoNothingHandler<T1>)));
 
-  ASSERT(!h->SetStartSequenceHandler(
+  ASSERT(!h.SetStartSequenceHandler(
               r_str, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T2>)));
-  ASSERT(h->SetStartSequenceHandler(
+  ASSERT(h.SetStartSequenceHandler(
               r_str, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T1>)));
 
-  ASSERT(!h->SetEndSequenceHandler(
+  ASSERT(!h.SetEndSequenceHandler(
               r_str, UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetEndSequenceHandler(
+  ASSERT(h.SetEndSequenceHandler(
               r_str, UpbMakeHandler(DoNothingHandler<T1>)));
 
   // By setting T1 as the return type for the Start* handlers we have
   // established T1 as the type of the sequence and string frames.
   // Setting callbacks that use T2 should fail, but T1 should succeed.
   ASSERT(
-      !h->SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler<T2>)));
+      !h.SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler<T2>)));
   ASSERT(
-      h->SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler<T1>)));
+      h.SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler<T1>)));
 
-  ASSERT(!h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T2>)));
-  ASSERT(h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
+  ASSERT(!h.SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T2>)));
+  ASSERT(h.SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
 
-  ASSERT(!h->SetStartSubMessageHandler(
+  ASSERT(!h.SetStartSubMessageHandler(
               r_msg, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T2>)));
-  ASSERT(h->SetStartSubMessageHandler(
+  ASSERT(h.SetStartSubMessageHandler(
               r_msg, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T1>)));
 
-  ASSERT(!h->SetEndSubMessageHandler(r_msg,
+  ASSERT(!h.SetEndSubMessageHandler(r_msg,
                                      UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetEndSubMessageHandler(r_msg,
+  ASSERT(h.SetEndSubMessageHandler(r_msg,
                                     UpbMakeHandler(DoNothingHandler<T1>)));
 
-  ASSERT(!h->SetStartStringHandler(
+  ASSERT(!h.SetStartStringHandler(
               r_str, UpbMakeHandler(DoNothingStartHandler<T1>::String<T2>)));
-  ASSERT(h->SetStartStringHandler(
+  ASSERT(h.SetStartStringHandler(
               r_str, UpbMakeHandler(DoNothingStartHandler<T1>::String<T1>)));
 
   ASSERT(
-      !h->SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler<T1>)));
+      !h.SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler<T2>)));
+  ASSERT(h.SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler<T1>)));
 
-  ASSERT(!h->SetStringHandler(r_str,
+  ASSERT(!h.SetStringHandler(r_str,
                               UpbMakeHandler(DoNothingStringBufHandler<T2>)));
-  ASSERT(h->SetStringHandler(r_str,
+  ASSERT(h.SetStringHandler(r_str,
                              UpbMakeHandler(DoNothingStringBufHandler<T1>)));
+}
 
-  h->ClearError();
-  ASSERT(h->Freeze(NULL));
+void RegisterMismatchedTypes2(const void* closure, upb::Handlers* h_ptr) {
+  upb::HandlersPtr h(h_ptr);
+
+  upb::MessageDefPtr md(h.message_def());
+  ASSERT(md);
+  upb::FieldDefPtr i32 = md.FindFieldByName("i32");
+  upb::FieldDefPtr r_i32 = md.FindFieldByName("r_i32");
+  upb::FieldDefPtr str = md.FindFieldByName("str");
+  upb::FieldDefPtr r_str = md.FindFieldByName("r_str");
+  upb::FieldDefPtr msg = md.FindFieldByName("msg");
+  upb::FieldDefPtr r_msg = md.FindFieldByName("r_msg");
+  ASSERT(i32);
+  ASSERT(r_i32);
+  ASSERT(str);
+  ASSERT(r_str);
+  ASSERT(msg);
+  ASSERT(r_msg);
 
   // For our second test we do the same in reverse.  We directly set the type of
   // the frame and then observe failures at registering a Start* handler that
   // returns a different type.
-  h = upb::Handlers::New(md.get());
 
   // First establish the type of a sequence frame directly.
-  ASSERT(h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
+  ASSERT(h.SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
 
   // Now setting a StartSequence callback that returns a different type should
   // fail.
-  ASSERT(!h->SetStartSequenceHandler(
+  ASSERT(!h.SetStartSequenceHandler(
               r_i32, UpbMakeHandler(DoNothingStartHandler<T2>::Handler<T1>)));
-  ASSERT(h->SetStartSequenceHandler(
+  ASSERT(h.SetStartSequenceHandler(
               r_i32, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T1>)));
 
   // Establish a string frame directly.
-  ASSERT(h->SetStringHandler(r_str,
+  ASSERT(h.SetStringHandler(r_str,
                              UpbMakeHandler(DoNothingStringBufHandler<T1>)));
 
   // Fail setting a StartString callback that returns a different type.
-  ASSERT(!h->SetStartStringHandler(
+  ASSERT(!h.SetStartStringHandler(
               r_str, UpbMakeHandler(DoNothingStartHandler<T2>::String<T1>)));
-  ASSERT(h->SetStartStringHandler(
+  ASSERT(h.SetStartStringHandler(
       r_str, UpbMakeHandler(DoNothingStartHandler<T1>::String<T1>)));
 
   // The previous established T1 as the frame for the r_str sequence.
-  ASSERT(!h->SetStartSequenceHandler(
+  ASSERT(!h.SetStartSequenceHandler(
               r_str, UpbMakeHandler(DoNothingStartHandler<T2>::Handler<T1>)));
-  ASSERT(h->SetStartSequenceHandler(
+  ASSERT(h.SetStartSequenceHandler(
       r_str, UpbMakeHandler(DoNothingStartHandler<T1>::Handler<T1>)));
+}
 
-  // Now test for this error that is not caught until freeze time:
-  // Change-of-closure-type implies that a StartSequence or StartString handler
-  // should exist to return the closure type of the inner frame but no
-  // StartSequence/StartString handler is registered.
-
-  h = upb::Handlers::New(md.get());
-
-  // Establish T1 as top-level closure type.
-  ASSERT(h->SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
+void TestMismatchedTypes() {
+  // First create a schema for our test.
+  upb::SymbolTable symtab;
+  upb::HandlerCache handler_cache(&RegisterMismatchedTypes, nullptr);
+  upb::HandlerCache handler_cache2(&RegisterMismatchedTypes2, nullptr);
+  const upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr()));
 
-  // Establish T2 as closure type of sequence frame.
-  ASSERT(
-      h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T2>)));
-
-  // Now attempt to freeze; this should fail because a StartSequence handler
-  // needs to be registered that takes a T1 and returns a T2.
-  ASSERT(!h->Freeze(NULL));
-
-  // Now if we register the necessary StartSequence handler, the freezing should
-  // work.
-  ASSERT(h->SetStartSequenceHandler(
-      r_i32, UpbMakeHandler(DoNothingStartHandler<T2>::Handler<T1>)));
-  h->ClearError();
-  ASSERT(h->Freeze(NULL));
-
-  // Test for a broken chain that is two deep.
-  h = upb::Handlers::New(md.get());
-
-  // Establish T1 as top-level closure type.
-  ASSERT(h->SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
-
-  // Establish T2 as the closure type of the string frame inside a sequence
-  // frame.
-  ASSERT(h->SetStringHandler(r_str,
-                             UpbMakeHandler(DoNothingStringBufHandler<T2>)));
-
-  // Now attempt to freeze; this should fail because a StartSequence or
-  // StartString handler needs to be registered that takes a T1 and returns a
-  // T2.
-  ASSERT(!h->Freeze(NULL));
-
-  // Now if we register a StartSequence handler it succeeds.
-  ASSERT(h->SetStartSequenceHandler(
-      r_str, UpbMakeHandler(DoNothingStartHandler<T2>::Handler<T1>)));
-  h->ClearError();
-  ASSERT(h->Freeze(NULL));
-
-  // TODO(haberman): test that closure returned by StartSubMessage does not
-  // match top-level closure of sub-handlers.
+  // Now test the type-checking in handler registration.
+  handler_cache.Get(md);
+  handler_cache2.Get(md);
 }
 
 class IntIncrementer {
@@ -1102,147 +871,51 @@ class IntIncrementer {
   int* x_;
 };
 
+void RegisterIncrementor(const void* closure, upb::Handlers* h_ptr) {
+  const int* x = static_cast<const int*>(closure);
+  upb::HandlersPtr h(h_ptr);
+  upb::FieldDefPtr f = h.message_def().FindFieldByName("i32");
+  h.SetInt32Handler(f, UpbBind(&IntIncrementer::Handler,
+                               new IntIncrementer(const_cast<int*>(x))));
+}
 
 void TestHandlerDataDestruction() {
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::reffed_ptr<upb::FieldDef> f(upb::FieldDef::New());
-  f->set_type(UPB_TYPE_INT32);
-  ASSERT(f->set_name("test", NULL));
-  ASSERT(f->set_number(1, NULL));
-  ASSERT(md->AddField(f, NULL));
-  ASSERT(md->Freeze(NULL));
-
   int x = 0;
+
   {
-    upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md.get()));
-    h->SetInt32Handler(
-        f.get(), UpbBind(&IntIncrementer::Handler, new IntIncrementer(&x)));
+    upb::SymbolTable symtab;
+    upb::HandlerCache cache(&RegisterIncrementor, &x);
+    upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr()));
+    cache.Get(md);
     ASSERT(x == 1);
   }
 
   ASSERT(x == 0);
 }
 
-void TestOneofs() {
-  upb::Status status;
-  upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New());
-  upb::reffed_ptr<upb::OneofDef> o(upb::OneofDef::New());
-
-  o->set_name("test_oneof", &status);
-  ASSERT(status.ok());
-
-  for (int i = 0; i < 5; i++) {
-    std::ostringstream fieldname;
-    fieldname << "field_" << i;
-    upb::reffed_ptr<upb::FieldDef> f(upb::FieldDef::New());
-    f->set_name(fieldname.str(), &status);
-    ASSERT(status.ok());
-    f->set_type(UPB_TYPE_INT32);
-    f->set_number(i + 1, &status);
-    ASSERT(status.ok());
-    f->set_label(UPB_LABEL_OPTIONAL);
-
-    o->AddField(f.get(), &status);
-    ASSERT(status.ok());
-  }
-
-  md->AddOneof(o.get(), &status);
-  ASSERT(status.ok());
+void TestIteration() {
+  upb::SymbolTable symtab;
+  upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr()));
 
-  int field_count = 0;
-  for (upb::OneofDef::iterator it = o->begin(); it != o->end(); ++it) {
-    upb::FieldDef* f = *it;
-    ASSERT(f->type() == UPB_TYPE_INT32);
-    field_count++;
-  }
-  ASSERT(field_count == 5);
-
-  upb::MessageDef::oneof_iterator msg_it = md->oneof_begin();
-  ASSERT(msg_it != md->oneof_end());
-  ASSERT((*msg_it) == o.get());
-
-#ifdef UPB_CXX11
   // Test range-based for on both fields and oneofs (with the iterator adaptor).
-  field_count = 0;
-  for (auto* field : md->fields()) {
+  int field_count = 0;
+  for (auto field : md.fields()) {
     UPB_UNUSED(field);
     field_count++;
   }
-  ASSERT(field_count == 5);
+  ASSERT(field_count == md.field_count());
 
   int oneof_count = 0;
-  for (auto* oneof : md->oneofs()) {
+  for (auto oneof : md.oneofs()) {
     UPB_UNUSED(oneof);
     oneof_count++;
   }
-  ASSERT(oneof_count == 1);
-#endif  //  UPB_CXX11
-
-  // Test that we can add a new field to the oneof and that it becomes a member
-  // of the msgdef as well.
-  upb::reffed_ptr<upb::FieldDef> newf(upb::FieldDef::New());
-  newf->set_name("new_field_10", &status);
-  ASSERT(status.ok());
-  newf->set_number(10, &status);
-  ASSERT(status.ok());
-  newf->set_label(UPB_LABEL_OPTIONAL);
-  newf->set_type(UPB_TYPE_INT32);
-  o->AddField(newf.get(), &status);
-  ASSERT(status.ok());
-  ASSERT(newf->containing_type() == md.get());
-
-  // Test that we can add a new field to the msgdef first and then to the oneof.
-  upb::reffed_ptr<upb::FieldDef> newf2(upb::FieldDef::New());
-  newf2->set_name("new_field_11", &status);
-  ASSERT(status.ok());
-  newf2->set_number(11, &status);
-  ASSERT(status.ok());
-  newf2->set_label(UPB_LABEL_OPTIONAL);
-  newf2->set_type(UPB_TYPE_INT32);
-  md->AddField(newf2.get(), &status);
-  ASSERT(status.ok());
-  o->AddField(newf2.get(), &status);
-  ASSERT(status.ok());
-  ASSERT(newf2->containing_oneof() == o.get());
-
-  // Test that we cannot add REQUIRED or REPEATED fields to the oneof.
-  upb::reffed_ptr<upb::FieldDef> newf3(upb::FieldDef::New());
-  newf3->set_name("new_field_12", &status);
-  ASSERT(status.ok());
-  newf3->set_number(12, &status);
-  ASSERT(status.ok());
-  newf3->set_label(UPB_LABEL_REQUIRED);
-  newf3->set_type(UPB_TYPE_INT32);
-  o->AddField(newf3.get(), &status);
-  ASSERT(!status.ok());
-  newf->set_label(UPB_LABEL_REPEATED);
-  o->AddField(newf3.get(), &status);
-  ASSERT(!status.ok());
+  ASSERT(oneof_count == md.oneof_count());
 }
 
 extern "C" {
 
 int run_tests(int argc, char *argv[]) {
-  if (argc < 2) {
-    fprintf(stderr, "Usage: test_cpp <descriptor file>\n");
-    return 1;
-  }
-  TestSymbolTable(argv[1]);
-  TestCastsUpDown();
-  TestCasts1();
-  TestCasts2();
-  TestCastsConst0();
-  TestCastsConst1();
-  TestCastsConst2();
-  TestCastsConst3();
-  TestCastsConst4();
-  TestCastsConst5();
-  TestCastsConst6();
-  TestCastsConst7();
-  TestCastsConst8();
-  TestCastsConst9();
-  TestCastsConst10();
-
   TestHandler<ValueTesterInt32VoidFunctionNoHandlerData>();
   TestHandler<ValueTesterInt32BoolFunctionNoHandlerData>();
   TestHandler<ValueTesterInt32VoidMethodNoHandlerData>();
@@ -1275,8 +948,7 @@ int run_tests(int argc, char *argv[]) {
   TestMismatchedTypes();
 
   TestHandlerDataDestruction();
-
-  TestOneofs();
+  TestIteration();
 
   return 0;
 }
diff --git a/tests/test_cpp.proto b/tests/test_cpp.proto
new file mode 100644
index 0000000..f890350
--- /dev/null
+++ b/tests/test_cpp.proto
@@ -0,0 +1,12 @@
+syntax = "proto2";
+
+package upb.test;
+
+message TestMessage {
+  optional int32 i32 = 1;
+  repeated int32 r_i32 = 2;
+  optional string str = 3;
+  repeated string r_str = 4;
+  optional TestMessage msg = 5;
+  repeated TestMessage r_msg = 6;
+}
diff --git a/tests/test_def.c b/tests/test_def.c
deleted file mode 100644
index d82fddb..0000000
--- a/tests/test_def.c
+++ /dev/null
@@ -1,453 +0,0 @@
-/*
-** Test of defs and symtab.  There should be far more tests of edge conditions
-** (like attempts to link defs that don't have required properties set).
-*/
-
-#include "tests/test_util.h"
-#include "upb/def.h"
-#include "upb/pb/glue.h"
-#include "upb_test.h"
-#include <stdlib.h>
-#include <string.h>
-
-const char *descriptor_file;
-
-static void test_empty_symtab() {
-  upb_symtab *s = upb_symtab_new();
-  upb_symtab_iter i;
-  for (upb_symtab_begin(&i, s, UPB_DEF_ANY); !upb_symtab_done(&i);
-       upb_symtab_next(&i)) {
-    ASSERT(false);  /* Should not get here. */
-  }
-  upb_symtab_free(s);
-}
-
-static void test_noreftracking() {
-  /* Reftracking is not required; clients can pass UPB_UNTRACKED_REF for owner. */
-  upb_msgdef *md = upb_msgdef_new(UPB_UNTRACKED_REF);
-  upb_msgdef_ref(md, UPB_UNTRACKED_REF);
-
-  /* Clients can mix tracked and untracked refs. */
-  upb_msgdef_ref(md, &md);
-
-  upb_msgdef_unref(md, UPB_UNTRACKED_REF);
-  upb_msgdef_unref(md, UPB_UNTRACKED_REF);
-
-  /* Call some random function on the messagedef to test that it is alive. */
-  ASSERT(!upb_msgdef_isfrozen(md));
-
-  upb_msgdef_unref(md, &md);
-}
-
-static upb_symtab *load_test_proto() {
-  upb_symtab *s = upb_symtab_new();
-  upb_status status = UPB_STATUS_INIT;
-  size_t len;
-  char *data = upb_readfile(descriptor_file, &len);
-  upb_filedef **files, **files_ptr;
-  ASSERT(s);
-  ASSERT(data);
-  files = upb_loaddescriptor(data, len, &files, &status);
-  ASSERT(files);
-  free(data);
-
-  files_ptr = files;
-  while (*files_ptr) {
-    bool ok;
-    ASSERT(!upb_filedef_isfrozen(*files_ptr));
-    ok = upb_symtab_addfile(s, *files_ptr, &status);
-    ASSERT(ok);
-    ASSERT(upb_filedef_isfrozen(*files_ptr));
-    upb_filedef_unref(*files_ptr, &files);
-    files_ptr++;
-  }
-
-  upb_gfree(files);
-
-  return s;
-}
-
-static void test_cycles() {
-  bool ok;
-  upb_symtab *s = load_test_proto();
-  const upb_msgdef *m;
-  const upb_fielddef *f;
-  const upb_def *def;
-  const upb_def *def2;
-
-  /* Test cycle detection by making a cyclic def's main refcount go to zero
-   * and then be incremented to one again. */
-  def = upb_symtab_lookup(s, "A");
-  upb_def_ref(def, &def);
-  ASSERT(def);
-  ASSERT(upb_def_isfrozen(def));
-  upb_symtab_free(s);
-
-  /* Message A has only one subfield: "optional B b = 1". */
-  m = upb_downcast_msgdef(def);
-  f = upb_msgdef_itof(m, 1);
-  ASSERT(f);
-  ASSERT(upb_fielddef_hassubdef(f));
-  ASSERT(upb_msgdef_ntofz(m, "b") == f);
-  ASSERT(upb_msgdef_ntof(m, "b", 1) == f);
-  def2 = upb_fielddef_subdef(f);
-  ASSERT(upb_downcast_msgdef(def2));
-  ok = strcmp(upb_def_fullname(def2), "B") == 0;
-  ASSERT(ok);
-
-  upb_def_ref(def2, &def2);
-  upb_def_unref(def, &def);
-
-  /* We know "def" is still alive because it's reachable from def2. */
-  ok = strcmp(upb_def_fullname(def), "A") == 0;
-  ASSERT(ok);
-  upb_def_unref(def2, &def2);
-}
-
-static void test_symbol_resolution() {
-  upb_status s = UPB_STATUS_INIT;
-  upb_def *defs[2];
-  upb_msgdef *m1;
-  upb_msgdef *m2;
-  upb_msgdef *m3;
-  upb_fielddef *m3_field1;
-  upb_fielddef *m3_field2;
-
-  upb_symtab *symtab = upb_symtab_new(&symtab);
-  ASSERT(symtab);
-
-  /* m1 has name "A.B.C" and no fields. We'll add it to the symtab now. */
-  m1 = upb_msgdef_new(&m1);
-  ASSERT(m1);
-  ASSERT_STATUS(upb_msgdef_setfullname(m1, "A.B.C", &s), &s);
-  ASSERT_STATUS(upb_symtab_add(symtab, (upb_def**)&m1, 1,
-                               NULL, &s), &s);
-
-  /* m2 has name "D.E" and no fields. We'll add it in the same batch as m3
-   * below. */
-  m2 = upb_msgdef_new(&m2);
-  ASSERT(m2);
-  ASSERT_STATUS(upb_msgdef_setfullname(m2, "D.E", &s), &s);
-
-  /* m3 has name "F.G" and two fields, of type A.B.C and D.E respectively. We'll
-   * add it in the same batch as m2 above. */
-  m3 = upb_msgdef_new(&m3);
-  ASSERT(m3);
-  ASSERT_STATUS(upb_msgdef_setfullname(m3, "F.G", &s), &s);
-  m3_field1 = upb_fielddef_new(&m3_field1);
-  ASSERT_STATUS(upb_fielddef_setname(m3_field1, "field1", &s), &s);
-  ASSERT_STATUS(upb_fielddef_setnumber(m3_field1, 1, &s), &s);
-  upb_fielddef_setlabel(m3_field1, UPB_LABEL_OPTIONAL);
-  upb_fielddef_settype(m3_field1, UPB_TYPE_MESSAGE);
-  ASSERT_STATUS(upb_fielddef_setsubdefname(m3_field1, ".A.B.C", &s), &s);
-  ASSERT_STATUS(upb_msgdef_addfield(m3, m3_field1, NULL, &s), &s);
-
-  m3_field2 = upb_fielddef_new(&m3_field2);
-  ASSERT_STATUS(upb_fielddef_setname(m3_field2, "field2", &s), &s);
-  ASSERT_STATUS(upb_fielddef_setnumber(m3_field2, 2, &s), &s);
-  upb_fielddef_setlabel(m3_field2, UPB_LABEL_OPTIONAL);
-  upb_fielddef_settype(m3_field2, UPB_TYPE_MESSAGE);
-  ASSERT_STATUS(upb_fielddef_setsubdefname(m3_field2, ".D.E", &s), &s);
-  ASSERT_STATUS(upb_msgdef_addfield(m3, m3_field2, NULL, &s), &s);
-
-  defs[0] = upb_msgdef_upcast_mutable(m2);
-  defs[1] = upb_msgdef_upcast_mutable(m3);
-  ASSERT_STATUS(upb_symtab_add(symtab, defs, 2, NULL, &s), &s);
-
-  upb_fielddef_unref(m3_field2, &m3_field2);
-  upb_fielddef_unref(m3_field1, &m3_field1);
-  upb_msgdef_unref(m3, &m3);
-  upb_msgdef_unref(m2, &m2);
-  upb_msgdef_unref(m1, &m1);
-  upb_symtab_free(symtab);
-}
-
-static void test_fielddef_unref() {
-  bool ok;
-  upb_symtab *s = load_test_proto();
-  const upb_msgdef *md = upb_symtab_lookupmsg(s, "A");
-  const upb_fielddef *f = upb_msgdef_itof(md, 1);
-  upb_fielddef_ref(f, &f);
-
-  /* Unref symtab; now fielddef is the only thing keeping the msgdef alive. */
-  upb_symtab_free(s);
-  /* Check that md is still alive. */
-  ok = strcmp(upb_msgdef_fullname(md), "A") == 0;
-  ASSERT(ok);
-
-  /* Check that unref of fielddef frees the whole remaining graph. */
-  upb_fielddef_unref(f, &f);
-}
-
-static void test_fielddef() {
-  /* Test that we don't leak an unresolved subdef name. */
-  upb_fielddef *f1 = upb_fielddef_new(&f1);
-  upb_fielddef_settype(f1, UPB_TYPE_MESSAGE);
-  ASSERT(upb_fielddef_setsubdefname(f1, "YO", NULL));
-  upb_fielddef_unref(f1, &f1);
-}
-
-static upb_fielddef *newfield(
-    const char *name, int32_t num, uint8_t type, uint8_t label,
-    const char *type_name, void *owner) {
-  upb_fielddef *f = upb_fielddef_new(owner);
-  ASSERT(upb_fielddef_setname(f, name, NULL));
-  ASSERT(upb_fielddef_setnumber(f, num, NULL));
-  upb_fielddef_settype(f, type);
-  upb_fielddef_setlabel(f, label);
-  if (type_name) {
-    ASSERT(upb_fielddef_setsubdefname(f, type_name, NULL));
-  }
-  return f;
-}
-
-static upb_msgdef *upb_msgdef_newnamed(const char *name, void *owner) {
-  upb_msgdef *m = upb_msgdef_new(owner);
-  upb_msgdef_setfullname(m, name, NULL);
-  return m;
-}
-
-static void test_replacement_fails() {
-  bool ok;
-  upb_symtab *s = upb_symtab_new(&s);
-  upb_status status = UPB_STATUS_INIT;
-  upb_def *newdefs[2];
-
-  upb_msgdef *m = upb_msgdef_newnamed("MyMessage", &s);
-  upb_msgdef *m2 = upb_msgdef_newnamed("MyMessage", &s);
-
-  newdefs[0] = upb_msgdef_upcast_mutable(m);
-  newdefs[1] = upb_msgdef_upcast_mutable(m2);
-  ok = upb_symtab_add(s, newdefs, 2, &s, &status);
-  ASSERT(ok == false);
-  upb_status_clear(&status);
-
-  /* Adding just one is ok. */
-  ASSERT_STATUS(upb_symtab_add(s, newdefs, 1, &s, &status), &status);
-
-  /* Adding a conflicting one is not ok. */
-  newdefs[0] = upb_msgdef_upcast_mutable(m2);
-  ok = upb_symtab_add(s, newdefs, 1, &s, &status);
-  ASSERT(ok == false);
-
-  upb_symtab_free(s);
-}
-
-static void test_freeze_free() {
-  bool ok;
-
-  /* Test that freeze frees defs that were only being kept alive by virtue of
-   * sharing a group with other defs that are being frozen. */
-  upb_msgdef *m1 = upb_msgdef_newnamed("M1", &m1);
-  upb_msgdef *m2 = upb_msgdef_newnamed("M2", &m2);
-  upb_msgdef *m3 = upb_msgdef_newnamed("M3", &m3);
-  upb_msgdef *m4 = upb_msgdef_newnamed("M4", &m4);
-  upb_fielddef *f = upb_fielddef_new(&f);
-
-  /* Freeze M4 and make M1 point to it. */
-  upb_def_freeze((upb_def*const*)&m4, 1, NULL);
-
-  upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
-  ASSERT(upb_fielddef_setnumber(f, 1, NULL));
-  ASSERT(upb_fielddef_setname(f, "foo", NULL));
-  ASSERT(upb_fielddef_setmsgsubdef(f, m4, NULL));
-
-  ASSERT(upb_msgdef_addfield(m1, f, &f, NULL));
-
-  /* After this unref, M1 is the only thing keeping M4 alive. */
-  upb_msgdef_unref(m4, &m4);
-
-  /* Force M1/M2/M3 into a single mutable refcounting group. */
-  f = upb_fielddef_new(&f);
-  upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
-  ASSERT(upb_fielddef_setnumber(f, 1, NULL));
-  ASSERT(upb_fielddef_setname(f, "foo", NULL));
-
-  ASSERT(upb_fielddef_setmsgsubdef(f, m1, NULL));
-  ASSERT(upb_fielddef_setmsgsubdef(f, m2, NULL));
-  ASSERT(upb_fielddef_setmsgsubdef(f, m3, NULL));
-
-  /* Make M3 cyclic with itself. */
-  ASSERT(upb_msgdef_addfield(m3, f, &f, NULL));
-
-  /* These will be kept alive since they are in the same refcounting group as
-   * M3, which still has a ref.  Note: this behavior is not guaranteed by the
-   * API, but true in practice with its current implementation. */
-  upb_msgdef_unref(m1, &m1);
-  upb_msgdef_unref(m2, &m2);
-
-  /* Test that they are still alive (NOT allowed by the API). */
-  ok = strcmp("M1", upb_msgdef_fullname(m1)) == 0;
-  ASSERT(ok);
-  ok = strcmp("M2", upb_msgdef_fullname(m2)) == 0;
-  ASSERT(ok);
-
-  /* Freeze M3.  If the test leaked no memory, then freeing m1 and m2 was
-   * successful. */
-  ASSERT(upb_def_freeze((upb_def*const*)&m3, 1, NULL));
-
-  upb_msgdef_unref(m3, &m3);
-}
-
-static void test_partial_freeze() {
-  /* Test that freeze of only part of the graph correctly adjusts objects that
-   * point to the newly-frozen objects. */
-  upb_msgdef *m1 = upb_msgdef_newnamed("M1", &m1);
-  upb_msgdef *m2 = upb_msgdef_newnamed("M2", &m2);
-  upb_msgdef *m3 = upb_msgdef_newnamed("M3", &m3);
-  upb_fielddef *f1 = upb_fielddef_new(&f1);
-  upb_fielddef *f2 = upb_fielddef_new(&f2);
-  upb_def *defs[2];
-  defs[0] = upb_msgdef_upcast_mutable(m1);
-  defs[1] = upb_msgdef_upcast_mutable(m2);
-
-  upb_fielddef_settype(f1, UPB_TYPE_MESSAGE);
-  ASSERT(upb_fielddef_setnumber(f1, 1, NULL));
-  ASSERT(upb_fielddef_setname(f1, "f1", NULL));
-  ASSERT(upb_fielddef_setmsgsubdef(f1, m1, NULL));
-
-  upb_fielddef_settype(f2, UPB_TYPE_MESSAGE);
-  ASSERT(upb_fielddef_setnumber(f2, 2, NULL));
-  ASSERT(upb_fielddef_setname(f2, "f2", NULL));
-  ASSERT(upb_fielddef_setmsgsubdef(f2, m2, NULL));
-
-  ASSERT(upb_msgdef_addfield(m3, f1, &f1, NULL));
-  ASSERT(upb_msgdef_addfield(m3, f2, &f2, NULL));
-
-  /* Freeze M1 and M2, which should cause the group to be split
-   * and m3 (left mutable) to take references on m1 and m2. */
-  ASSERT(upb_def_freeze(defs, 2, NULL));
-
-  ASSERT(upb_msgdef_isfrozen(m1));
-  ASSERT(upb_msgdef_isfrozen(m2));
-  ASSERT(!upb_msgdef_isfrozen(m3));
-
-  upb_msgdef_unref(m1, &m1);
-  upb_msgdef_unref(m2, &m2);
-  upb_msgdef_unref(m3, &m3);
-}
-
-static void test_descriptor_flags() {
-  upb_msgdef *m = upb_msgdef_new(&m);
-  upb_status s = UPB_STATUS_INIT;
-
-  ASSERT(upb_msgdef_mapentry(m) == false);
-  upb_msgdef_setfullname(m, "TestMessage", &s);
-  ASSERT(upb_ok(&s));
-  upb_msgdef_setmapentry(m, true);
-  ASSERT(upb_msgdef_mapentry(m) == true);
-  upb_msgdef_unref(m, &m);
-}
-
-static void test_mapentry_check() {
-  upb_status s = UPB_STATUS_INIT;
-  upb_msgdef *m = upb_msgdef_new(&m);
-  upb_fielddef *f = upb_fielddef_new(&f);
-  upb_symtab *symtab = upb_symtab_new(&symtab);
-  upb_msgdef *subm = upb_msgdef_new(&subm);
-  upb_def *defs[2];
-
-  upb_msgdef_setfullname(m, "TestMessage", &s);
-  upb_fielddef_setname(f, "field1", &s);
-  upb_fielddef_setnumber(f, 1, &s);
-  upb_fielddef_setlabel(f, UPB_LABEL_OPTIONAL);
-  upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
-  upb_fielddef_setsubdefname(f, ".MapEntry", &s);
-  upb_msgdef_addfield(m, f, &f, &s);
-  ASSERT(upb_ok(&s));
-
-  upb_msgdef_setfullname(subm, "MapEntry", &s);
-  upb_msgdef_setmapentry(subm, true);
-
-  defs[0] = upb_msgdef_upcast_mutable(m);
-  defs[1] = upb_msgdef_upcast_mutable(subm);
-  upb_symtab_add(symtab, defs, 2, NULL, &s);
-  /* Should not have succeeded: non-repeated field pointing to a MapEntry. */
-  ASSERT(!upb_ok(&s));
-
-  upb_status_clear(&s);
-  upb_fielddef_setlabel(f, UPB_LABEL_REPEATED);
-  upb_symtab_add(symtab, defs, 2, NULL, &s);
-  ASSERT(upb_ok(&s));
-
-  upb_symtab_free(symtab);
-  upb_msgdef_unref(subm, &subm);
-  upb_msgdef_unref(m, &m);
-}
-
-static void test_oneofs() {
-  upb_status s = UPB_STATUS_INIT;
-  bool ok = true;
-  upb_def *subm_defs[1];
-  upb_symtab *symtab = upb_symtab_new(&symtab);
-  upb_msgdef *subm = upb_msgdef_newnamed("SubMessage", &symtab);
-  upb_msgdef *m = upb_msgdef_newnamed("TestMessage", &symtab);
-  upb_oneofdef *o = upb_oneofdef_new(&o);
-  const upb_oneofdef *lookup_o;
-  const upb_fielddef *lookup_field;
-  upb_def *defs[1];
-
-  ASSERT(symtab != NULL);
-
-  /* Create a test message for fields to refer to. */
-  upb_msgdef_addfield(subm, newfield("field1", 1, UPB_TYPE_INT32,
-                                     UPB_LABEL_OPTIONAL, NULL, &symtab),
-                      &symtab, NULL);
-  subm_defs[0] = upb_msgdef_upcast_mutable(subm);
-  ASSERT_STATUS(upb_symtab_add(symtab, subm_defs, 1, &symtab, &s), &s);
-
-  ASSERT(upb_msgdef_numoneofs(m) == 0);
-
-  ASSERT(upb_oneofdef_numfields(o) == 0);
-  ASSERT(upb_oneofdef_name(o) == NULL);
-
-  ok = upb_oneofdef_setname(o, "test_oneof", &s);
-  ASSERT_STATUS(ok, &s);
-
-  ok = upb_oneofdef_addfield(o, newfield("field1", 1, UPB_TYPE_INT32,
-                                         UPB_LABEL_OPTIONAL, NULL, &symtab),
-                             &symtab, NULL);
-  ASSERT_STATUS(ok, &s);
-  ok = upb_oneofdef_addfield(o, newfield("field2", 2, UPB_TYPE_MESSAGE,
-                                         UPB_LABEL_OPTIONAL, ".SubMessage",
-                                         &symtab),
-                             &symtab, NULL);
-  ASSERT_STATUS(ok, &s);
-
-  ok = upb_msgdef_addoneof(m, o, NULL, &s);
-  ASSERT_STATUS(ok, &s);
-
-  defs[0] = upb_msgdef_upcast_mutable(m);
-  ASSERT_STATUS(upb_symtab_add(symtab, defs, 1, &symtab, &s), &s);
-
-  ASSERT(upb_msgdef_numoneofs(m) == 1);
-  lookup_o = upb_msgdef_ntooz(m, "test_oneof");
-  ASSERT(lookup_o == o);
-
-  lookup_field = upb_oneofdef_ntofz(o, "field1");
-  ASSERT(lookup_field != NULL && upb_fielddef_number(lookup_field) == 1);
-
-  upb_symtab_free(symtab);
-  upb_oneofdef_unref(o, &o);
-}
-
-int run_tests(int argc, char *argv[]) {
-  if (argc < 2) {
-    fprintf(stderr, "Usage: test_def <test.proto.pb>\n");
-    return 1;
-  }
-  descriptor_file = argv[1];
-  test_empty_symtab();
-  test_cycles();
-  test_symbol_resolution();
-  test_fielddef();
-  test_fielddef_unref();
-  test_replacement_fails();
-  test_freeze_free();
-  test_partial_freeze();
-  test_noreftracking();
-  test_descriptor_flags();
-  test_mapentry_check();
-  test_oneofs();
-  return 0;
-}
diff --git a/tests/test_handlers.c b/tests/test_handlers.c
deleted file mode 100644
index fe6fb82..0000000
--- a/tests/test_handlers.c
+++ /dev/null
@@ -1,41 +0,0 @@
-
-#include "upb/handlers.h"
-#include "upb/descriptor/descriptor.upbdefs.h"
-#include "upb_test.h"
-#include <stdlib.h>
-#include <string.h>
-
-static bool startmsg(void *c, const void *hd) {
-  UPB_UNUSED(c);
-  UPB_UNUSED(hd);
-  return true;
-}
-
-static void test_error() {
-  /* Test creating handlers of a static msgdef. */
-  const upb_msgdef *m = upbdefs_google_protobuf_DescriptorProto_get(&m);
-  upb_handlers *h = upb_handlers_new(m, &h);
-  upb_msgdef_unref(m, &m);
-
-  /* Attempt to set the same handler twice causes error. */
-  ASSERT(upb_ok(upb_handlers_status(h)));
-  upb_handlers_setstartmsg(h, &startmsg, NULL);
-  ASSERT(upb_ok(upb_handlers_status(h)));
-  upb_handlers_setstartmsg(h, &startmsg, NULL);
-  ASSERT(!upb_ok(upb_handlers_status(h)));
-  ASSERT(!upb_handlers_freeze(&h, 1, NULL));
-
-  /* Clearing the error will let us proceed. */
-  upb_handlers_clearerr(h);
-  ASSERT(upb_handlers_freeze(&h, 1, NULL));
-  ASSERT(upb_handlers_isfrozen(h));
-
-  upb_handlers_unref(h, &h);
-}
-
-int run_tests(int argc, char *argv[]) {
-  UPB_UNUSED(argc);
-  UPB_UNUSED(argv);
-  test_error();
-  return 0;
-}
diff --git a/tests/test_util.h b/tests/test_util.h
index f616c36..680673d 100644
--- a/tests/test_util.h
+++ b/tests/test_util.h
@@ -12,7 +12,7 @@
 
 #ifdef __cplusplus
 
-upb::BufferHandle global_handle;
+upb_bufhandle global_handle;
 
 /* A convenience class for parser tests.  Provides some useful features:
  *
@@ -30,33 +30,13 @@ upb::BufferHandle global_handle;
 class VerboseParserEnvironment {
  public:
   /* Pass verbose=true to print detailed diagnostics to stderr. */
-  VerboseParserEnvironment(bool verbose) : verbose_(verbose) {
-    env_.SetErrorFunction(&VerboseParserEnvironment::OnError, this);
-  }
-
-  static bool OnError(void *ud, const upb::Status* status) {
-    VerboseParserEnvironment* env = static_cast<VerboseParserEnvironment*>(ud);
-
-    env->saw_error_ = true;
-
-    if (env->expect_error_ && env->verbose_) {
-      fprintf(stderr, "Encountered error, as expected: ");
-    } else if (!env->expect_error_) {
-      fprintf(stderr, "Encountered unexpected error: ");
-    } else {
-      return false;
-    }
-
-    fprintf(stderr, "%s\n", status->error_message());
-    return false;
-  }
+  VerboseParserEnvironment(bool verbose) : verbose_(verbose) {}
 
   void Reset(const char *buf, size_t len, bool may_skip, bool expect_error) {
     buf_ = buf;
     len_ = len;
     ofs_ = 0;
     expect_error_ = expect_error;
-    saw_error_ = false;
     end_ok_set_ = false;
     skip_until_ = may_skip ? 0 : -1;
     skipped_with_null_ = false;
@@ -78,14 +58,14 @@ class VerboseParserEnvironment {
     if (verbose_) {
       fprintf(stderr, "Calling start()\n");
     }
-    return sink_->Start(len_, &subc_);
+    return sink_.Start(len_, &subc_);
   }
 
   bool End() {
     if (verbose_) {
       fprintf(stderr, "Calling end()\n");
     }
-    end_ok_ = sink_->End();
+    end_ok_ = sink_.End();
     end_ok_set_ = true;
 
     return end_ok_;
@@ -94,16 +74,27 @@ class VerboseParserEnvironment {
   bool CheckConsistency() {
     /* If we called end (which we should only do when previous bytes are fully
      * accepted), then end() should return true iff there were no errors. */
-    if (end_ok_set_ && end_ok_ != !saw_error_) {
+    if (end_ok_set_ && end_ok_ != status_.ok()) {
       fprintf(stderr, "End() status and saw_error didn't match.\n");
       return false;
     }
 
-    if (expect_error_ && !saw_error_) {
+    if (expect_error_ && status_.ok()) {
       fprintf(stderr, "Expected error but saw none.\n");
       return false;
     }
 
+    if (!status_.ok()) {
+      if (expect_error_ && verbose_) {
+        fprintf(stderr, "Encountered error, as expected: %s",
+                status_.error_message());
+      } else if (!expect_error_) {
+        fprintf(stderr, "Encountered unexpected error: %s",
+                status_.error_message());
+        return false;
+      }
+    }
+
     return true;
   }
 
@@ -137,7 +128,7 @@ class VerboseParserEnvironment {
               (unsigned)bytes, (unsigned)ofs_, (unsigned)(ofs_ + bytes));
     }
 
-    int parsed = sink_->PutBuffer(subc_, buf2, bytes, &global_handle);
+    int parsed = sink_.PutBuffer(subc_, buf2, bytes, &global_handle);
     free(buf2);
 
     if (verbose_) {
@@ -158,8 +149,9 @@ class VerboseParserEnvironment {
       }
     }
 
-    if (saw_error_)
+    if (!status_.ok()) {
       return false;
+    }
 
     if (parsed > bytes && skip_until_ >= 0) {
       skip_until_ = ofs_ + parsed;
@@ -170,25 +162,27 @@ class VerboseParserEnvironment {
     return true;
   }
 
-  void ResetBytesSink(upb::BytesSink* sink) {
+  void ResetBytesSink(upb::BytesSink sink) {
     sink_ = sink;
   }
 
   size_t ofs() { return ofs_; }
-  upb::Environment* env() { return &env_; }
 
   bool SkippedWithNull() { return skipped_with_null_; }
 
+  upb::Arena* arena() { return &arena_; }
+  upb::Status* status() { return &status_; }
+
  private:
-  upb::Environment env_;
-  upb::BytesSink* sink_;
+  upb::Arena arena_;
+  upb::Status status_;
+  upb::BytesSink sink_;
   const char* buf_;
   size_t len_;
   bool verbose_;
   size_t ofs_;
   void *subc_;
   bool expect_error_;
-  bool saw_error_;
   bool end_ok_;
   bool end_ok_set_;