All tests pass again!

tests/test_cpp.cc

@@ -52,16 +52,16 @@ class StringBufTesterBase {
 
   StringBufTesterBase() : seen_(false), handler_data_val_(0) {}
 
-  void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) {
+  void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) {
-    upb::Handlers::Selector start;
+    upb_selector_t start;
-    ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_STARTSTR, &start));
+    ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_STARTSTR, &start));
-    upb::Handlers::Selector str;
+    upb_selector_t str;
-    ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_STRING, &str));
+    ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_STRING, &str));
 
     ASSERT(!seen_);
     upb::Sink sub;
-    sink->StartMessage();
+    sink.StartMessage();
-    sink->StartString(start, 0, &sub);
+    sink.StartString(start, 0, &sub);
     size_t ret = sub.PutStringBuffer(str, &buf_, 5, &handle_);
     ASSERT(seen_);
     ASSERT(len_ == 5);
@@ -74,7 +74,7 @@ class StringBufTesterBase {
   int handler_data_val_;
   size_t len_;
   char buf_;
-  upb::BufferHandle handle_;
+  upb_bufhandle handle_;
 };
 
 // Test 8 combinations of:
@@ -91,9 +91,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;
   }
 
@@ -109,14 +109,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;
@@ -128,9 +128,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))));
   }
 
@@ -147,15 +147,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;
@@ -168,9 +168,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;
   }
 
@@ -186,15 +186,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;
@@ -206,9 +206,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))));
   }
 
@@ -225,15 +225,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;
@@ -246,9 +246,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;
   }
 
@@ -265,9 +265,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;
   }
 
@@ -288,10 +288,10 @@ class StartMsgTesterBase {
 
   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);
   }
@@ -307,9 +307,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;
   }
 
@@ -323,9 +323,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;
   }
 
@@ -339,9 +339,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;
   }
 
@@ -354,9 +354,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;
   }
 
@@ -370,9 +370,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))));
   }
 
@@ -386,9 +386,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))));
   }
 
@@ -403,9 +403,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))));
   }
 
@@ -419,9 +419,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))));
   }
 
@@ -439,12 +439,12 @@ class Int32ValueTesterBase {
 
   Int32ValueTesterBase() : seen_(false), val_(0), handler_data_val_(0) {}
 
-  void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) {
+  void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) {
-    upb::Handlers::Selector s;
+    upb_selector_t s;
-    ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_INT32, &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);
@@ -463,8 +463,8 @@ class ValueTesterInt32VoidFunctionNoHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidFunctionNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler)));
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -479,8 +479,8 @@ class ValueTesterInt32BoolFunctionNoHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolFunctionNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler)));
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -495,8 +495,8 @@ class ValueTesterInt32BoolFunctionNoHandlerData
 class ValueTesterInt32VoidMethodNoHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidMethodNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -510,8 +510,8 @@ class ValueTesterInt32VoidMethodNoHandlerData : public Int32ValueTesterBase {
 class ValueTesterInt32BoolMethodNoHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolMethodNoHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
+    ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&ME::Handler)));
     handler_data_val_ = kExpectedHandlerData;
   }
 
@@ -527,8 +527,8 @@ class ValueTesterInt32VoidFunctionWithHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidFunctionWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&Handler, new int(kExpectedHandlerData))));
   }
 
@@ -544,8 +544,8 @@ class ValueTesterInt32BoolFunctionWithHandlerData
     : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolFunctionWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&Handler, new int(kExpectedHandlerData))));
   }
 
@@ -561,8 +561,8 @@ class ValueTesterInt32BoolFunctionWithHandlerData
 class ValueTesterInt32VoidMethodWithHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32VoidMethodWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -577,8 +577,8 @@ class ValueTesterInt32VoidMethodWithHandlerData : public Int32ValueTesterBase {
 class ValueTesterInt32BoolMethodWithHandlerData : public Int32ValueTesterBase {
  public:
   typedef ValueTesterInt32BoolMethodWithHandlerData ME;
-  void Register(upb::Handlers* h, const upb::FieldDef* f) {
+  void Register(upb::HandlersPtr h, upb::FieldDefPtr f) {
-    ASSERT(h->SetInt32Handler(
+    ASSERT(h.SetInt32Handler(
         f, UpbBind(&ME::Handler, new int(kExpectedHandlerData))));
   }
 
@@ -591,22 +591,29 @@ 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::SymbolTable* symtab = upb::SymbolTable::New();
+  T tester;
-  const upb::MessageDef* md = upb_test_TestMessage_getmsgdef(symtab);
+  upb::SymbolTable symtab;
+  upb::HandlerCache cache(&RegisterHandlers<T>, &tester);
+  upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr()));
   ASSERT(md);
-  const upb::FieldDef* f = md->FindFieldByNumber(T::kFieldNumber);
+  upb::FieldDefPtr f = md.FindFieldByNumber(T::kFieldNumber);
   ASSERT(f);
 
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md));
+  const upb::Handlers* h = cache.Get(md);
-  T tester;
-  tester.Register(h.get(), f);
-  ASSERT(h->Freeze(NULL));
 
-  upb::Sink sink(h.get(), &tester);
+  upb::Sink sink(h, &tester);
-  tester.CallAndVerify(&sink, f);
+  tester.CallAndVerify(sink, f);
-  upb::SymbolTable::Free(symtab);
 }
 
 class T1 {};
@@ -670,17 +677,17 @@ void DoNothingEndMessageHandler(C* closure, upb::Status *status) {
   UPB_UNUSED(status);
 }
 
-void TestMismatchedTypes() {
+void RegisterMismatchedTypes(const void* closure, upb::Handlers* h_ptr) {
-  // First create a schema for our test.
+  upb::HandlersPtr h(h_ptr);
-  upb::SymbolTable* symtab = upb::SymbolTable::New();
+
-  const upb::MessageDef* md = upb_test_TestMessage_getmsgdef(symtab);
+  upb::MessageDefPtr md(h.message_def());
   ASSERT(md);
-  const upb::FieldDef* i32 = md->FindFieldByName("i32");
+  upb::FieldDefPtr i32 = md.FindFieldByName("i32");
-  const upb::FieldDef* r_i32 = md->FindFieldByName("r_i32");
+  upb::FieldDefPtr r_i32 = md.FindFieldByName("r_i32");
-  const upb::FieldDef* str = md->FindFieldByName("str");
+  upb::FieldDefPtr str = md.FindFieldByName("str");
-  const upb::FieldDef* r_str = md->FindFieldByName("r_str");
+  upb::FieldDefPtr r_str = md.FindFieldByName("r_str");
-  const upb::FieldDef* msg = md->FindFieldByName("msg");
+  upb::FieldDefPtr msg = md.FindFieldByName("msg");
-  const upb::FieldDef* r_msg = md->FindFieldByName("r_msg");
+  upb::FieldDefPtr r_msg = md.FindFieldByName("r_msg");
   ASSERT(i32);
   ASSERT(r_i32);
   ASSERT(str);
@@ -688,189 +695,163 @@ void TestMismatchedTypes() {
   ASSERT(msg);
   ASSERT(r_msg);
 
-  // Now test the type-checking in handler registration.
-  upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md));
-
   // 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<T2>)));
-  ASSERT(h->SetStartMessageHandler(UpbMakeHandler(DoNothingHandler<T1>)));
+  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<T2>)));
-  ASSERT(h->SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler<T1>)));
+  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<T2>)));
-  ASSERT(h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
+  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>)));
+      !h.SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler<T2>)));
-  ASSERT(h->SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler<T1>)));
+  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();
+void RegisterMismatchedTypes2(const void* closure, upb::Handlers* h_ptr) {
-  ASSERT(h->Freeze(NULL));
+  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);
 
   // 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:
+void TestMismatchedTypes() {
-  // Change-of-closure-type implies that a StartSequence or StartString handler
+  // First create a schema for our test.
-  // should exist to return the closure type of the inner frame but no
+  upb::SymbolTable symtab;
-  // StartSequence/StartString handler is registered.
+  upb::HandlerCache handler_cache(&RegisterMismatchedTypes, nullptr);
-
+  upb::HandlerCache handler_cache2(&RegisterMismatchedTypes2, nullptr);
-  h = upb::Handlers::New(md);
+  const upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr()));
-
-  // Establish T1 as top-level closure type.
-  ASSERT(h->SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler<T1>)));
 
-  // Establish T2 as closure type of sequence frame.
+  // Now test the type-checking in handler registration.
-  ASSERT(
+  handler_cache.Get(md);
-      h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler<T2>)));
+  handler_cache2.Get(md);
-
-  // 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);
-
-  // 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.
 }
 
 class IntIncrementer {
@@ -889,17 +870,22 @@ 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::SymbolTable* symtab = upb::SymbolTable::New();
-  const upb::MessageDef* md = upb_test_TestMessage_getmsgdef(symtab);
-  const upb::FieldDef* f = md->FindFieldByName("i32");
-
   int x = 0;
+
   {
-    upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md));
+    upb::SymbolTable symtab;
-    h->SetInt32Handler(
+    upb::HandlerCache cache(&RegisterIncrementor, &x);
-        f, UpbBind(&IntIncrementer::Handler, new IntIncrementer(&x)));
+    upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr()));
+    cache.Get(md);
     ASSERT(x == 1);
   }
 

upb/handlers.c

@@ -91,7 +91,7 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
 
   if (closure_type && *context_closure_type &&
       closure_type != *context_closure_type) {
-    UPB_ASSERT(false);
+    return false;
   }
 
   if (closure_type)
@@ -103,7 +103,7 @@ static bool doset(upb_handlers *h, int32_t sel, const upb_fielddef *f,
     const void *return_type = set_attr.return_closure_type;
     const void *table_return_type = h->table[sel].attr.return_closure_type;
     if (return_type && table_return_type && return_type != table_return_type) {
-      UPB_ASSERT(false);
+      return false;
     }
 
     if (table_return_type && !return_type) {
@@ -168,7 +168,7 @@ bool checkstart(upb_handlers *h, const upb_fielddef *f, upb_handlertype_t type,
   return_closure_type = attr->return_closure_type;
   if (closure_type && return_closure_type &&
       closure_type != return_closure_type) {
-    UPB_ASSERT(false);
+    return false;
   }
   return true;
 }

upb/sink.h

@@ -326,18 +326,37 @@ class upb::Sink {
    *
    * For StartString(), the function will write a sink for the string to "sub."
    * The sub-sink must be used for any/all PutStringBuffer() calls. */
-  bool StartString(HandlersPtr::Selector s, size_t size_hint, Sink* sub);
+  bool StartString(HandlersPtr::Selector s, size_t size_hint, Sink* sub) {
+    upb_sink sub_c;
+    bool ret = upb_sink_startstr(&sink_, s, size_hint, &sub_c);
+    *sub = sub_c;
+    return ret;
+  }
+
   size_t PutStringBuffer(HandlersPtr::Selector s, const char *buf, size_t len,
-                         const upb_bufhandle *handle);
+                         const upb_bufhandle *handle) {
-  bool EndString(HandlersPtr::Selector s);
+    return upb_sink_putstring(&sink_, s, buf, len, handle);
+  }
+
+  bool EndString(HandlersPtr::Selector s) {
+    return upb_sink_endstr(&sink_, s);
+  }
 
   /* For submessage fields.
    *
    * For StartSubMessage(), the function will write a sink for the string to
    * "sub." The sub-sink must be used for any/all handlers called within the
    * submessage. */
-  bool StartSubMessage(HandlersPtr::Selector s, Sink* sub);
+  bool StartSubMessage(HandlersPtr::Selector s, Sink* sub) {
-  bool EndSubMessage(HandlersPtr::Selector s);
+    upb_sink sub_c;
+    bool ret = upb_sink_startsubmsg(&sink_, s, &sub_c);
+    *sub = sub_c;
+    return ret;
+  }
+
+  bool EndSubMessage(HandlersPtr::Selector s) {
+    return upb_sink_endsubmsg(&sink_, s);
+  }
 
   /* For repeated fields of any type, the sequence of values must be wrapped in
    * these calls.
@@ -345,8 +364,16 @@ class upb::Sink {
    * For StartSequence(), the function will write a sink for the string to
    * "sub." The sub-sink must be used for any/all handlers called within the
    * sequence. */
-  bool StartSequence(HandlersPtr::Selector s, Sink* sub);
+  bool StartSequence(HandlersPtr::Selector s, Sink* sub) {
-  bool EndSequence(HandlersPtr::Selector s);
+    upb_sink sub_c;
+    bool ret = upb_sink_startseq(&sink_, s, &sub_c);
+    *sub = sub_c;
+    return ret;
+  }
+
+  bool EndSequence(HandlersPtr::Selector s) {
+    return upb_sink_endseq(&sink_, s);
+  }
 
   /* Copy and assign specifically allowed.
    * We don't even bother making these members private because so many