google-protobuf 3.14.0-x86-linux → 3.15.0.rc.1-x86-linux

data/ext/google/protobuf_c/third_party/wyhash/wyhash.h

@@ -0,0 +1,145 @@
+/* Copyright 2020 王一 Wang Yi <godspeed_china@yeah.net>
+   This is free and unencumbered software released into the public domain. http://unlicense.org/
+   See github.com/wangyi-fudan/wyhash/ LICENSE
+ */
+#ifndef wyhash_final_version
+#define wyhash_final_version
+//defines that change behavior
+#ifndef WYHASH_CONDOM
+#define WYHASH_CONDOM 1 //0: read 8 bytes before and after boundaries, dangerous but fastest. 1: normal valid behavior 2: extra protection against entropy loss (probability=2^-63), aka. "blind multiplication"
+#endif
+#define WYHASH_32BIT_MUM 0	//faster on 32 bit system
+//includes
+#include <stdint.h>
+#include <string.h>
+#if defined(_MSC_VER) && defined(_M_X64)
+  #include <intrin.h>
+  #pragma intrinsic(_umul128)
+#endif
+#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
+  #define _likely_(x)	__builtin_expect(x,1)
+  #define _unlikely_(x)	__builtin_expect(x,0)
+#else
+  #define _likely_(x) (x)
+  #define _unlikely_(x) (x)
+#endif
+//mum function
+static inline uint64_t _wyrot(uint64_t x) { return (x>>32)|(x<<32); }
+static inline void _wymum(uint64_t *A, uint64_t *B){
+#if(WYHASH_32BIT_MUM)
+  uint64_t hh=(*A>>32)*(*B>>32), hl=(*A>>32)*(unsigned)*B, lh=(unsigned)*A*(*B>>32), ll=(uint64_t)(unsigned)*A*(unsigned)*B;
+  #if(WYHASH_CONDOM>1)
+  *A^=_wyrot(hl)^hh; *B^=_wyrot(lh)^ll;
+  #else
+  *A=_wyrot(hl)^hh; *B=_wyrot(lh)^ll;
+  #endif
+#elif defined(__SIZEOF_INT128__)
+  __uint128_t r=*A; r*=*B; 
+  #if(WYHASH_CONDOM>1)
+  *A^=(uint64_t)r; *B^=(uint64_t)(r>>64);
+  #else
+  *A=(uint64_t)r; *B=(uint64_t)(r>>64);
+  #endif
+#elif defined(_MSC_VER) && defined(_M_X64)
+  #if(WYHASH_CONDOM>1)
+  uint64_t  a,  b;
+  a=_umul128(*A,*B,&b);
+  *A^=a;  *B^=b;
+  #else
+  *A=_umul128(*A,*B,B);
+  #endif
+#else
+  uint64_t ha=*A>>32, hb=*B>>32, la=(uint32_t)*A, lb=(uint32_t)*B, hi, lo;
+  uint64_t rh=ha*hb, rm0=ha*lb, rm1=hb*la, rl=la*lb, t=rl+(rm0<<32), c=t<rl;
+  lo=t+(rm1<<32); c+=lo<t; hi=rh+(rm0>>32)+(rm1>>32)+c;
+  #if(WYHASH_CONDOM>1)
+  *A^=lo;  *B^=hi;
+  #else
+  *A=lo;  *B=hi;
+  #endif
+#endif
+}
+static inline uint64_t _wymix(uint64_t A, uint64_t B){ _wymum(&A,&B); return A^B; }
+//read functions
+#ifndef WYHASH_LITTLE_ENDIAN
+  #if defined(_WIN32) || defined(__LITTLE_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+    #define WYHASH_LITTLE_ENDIAN 1
+  #elif defined(__BIG_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    #define WYHASH_LITTLE_ENDIAN 0
+  #endif
+#endif
+#if (WYHASH_LITTLE_ENDIAN)
+static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v;}
+static inline uint64_t _wyr4(const uint8_t *p) { unsigned v; memcpy(&v, p, 4); return v;}
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
+static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return __builtin_bswap64(v);}
+static inline uint64_t _wyr4(const uint8_t *p) { unsigned v; memcpy(&v, p, 4); return __builtin_bswap32(v);}
+#elif defined(_MSC_VER)
+static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return _byteswap_uint64(v);}
+static inline uint64_t _wyr4(const uint8_t *p) { unsigned v; memcpy(&v, p, 4); return _byteswap_ulong(v);}
+#endif
+static inline uint64_t _wyr3(const uint8_t *p, unsigned k) { return (((uint64_t)p[0])<<16)|(((uint64_t)p[k>>1])<<8)|p[k-1];}
+//wyhash function
+static inline uint64_t _wyfinish16(const uint8_t *p, uint64_t len, uint64_t seed, const uint64_t *secret, uint64_t i){
+#if(WYHASH_CONDOM>0)
+  uint64_t a, b;
+  if(_likely_(i<=8)){
+    if(_likely_(i>=4)){ a=_wyr4(p); b=_wyr4(p+i-4); }
+    else if (_likely_(i)){ a=_wyr3(p,i); b=0; }
+    else a=b=0;
+  } 
+  else{ a=_wyr8(p); b=_wyr8(p+i-8); }
+  return _wymix(secret[1]^len,_wymix(a^secret[1], b^seed));
+#else
+  #define oneshot_shift ((i<8)*((8-i)<<3))
+  return _wymix(secret[1]^len,_wymix((_wyr8(p)<<oneshot_shift)^secret[1],(_wyr8(p+i-8)>>oneshot_shift)^seed));
+#endif
+}
+
+static inline uint64_t _wyfinish(const uint8_t *p, uint64_t len, uint64_t seed, const uint64_t *secret, uint64_t i){
+  if(_likely_(i<=16)) return _wyfinish16(p,len,seed,secret,i);
+  return _wyfinish(p+16,len,_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed),secret,i-16);
+}
+
+static inline uint64_t wyhash(const void *key, uint64_t len, uint64_t seed, const uint64_t *secret){
+  const uint8_t *p=(const uint8_t *)key;
+  uint64_t i=len; seed^=*secret;
+  if(_unlikely_(i>64)){
+    uint64_t see1=seed;
+    do{
+      seed=_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed)^_wymix(_wyr8(p+16)^secret[2],_wyr8(p+24)^seed);
+      see1=_wymix(_wyr8(p+32)^secret[3],_wyr8(p+40)^see1)^_wymix(_wyr8(p+48)^secret[4],_wyr8(p+56)^see1);
+      p+=64; i-=64;
+    }while(i>64);
+    seed^=see1;
+  }
+  return _wyfinish(p,len,seed,secret,i);
+}
+//utility functions
+static const uint64_t _wyp[5] = {0xa0761d6478bd642full, 0xe7037ed1a0b428dbull, 0x8ebc6af09c88c6e3ull, 0x589965cc75374cc3ull, 0x1d8e4e27c47d124full};
+static inline uint64_t wyhash64(uint64_t A, uint64_t B){  A^=_wyp[0]; B^=_wyp[1];  _wymum(&A,&B);  return _wymix(A^_wyp[0],B^_wyp[1]);}
+static inline uint64_t wyrand(uint64_t *seed){  *seed+=_wyp[0]; return _wymix(*seed,*seed^_wyp[1]);}
+static inline double wy2u01(uint64_t r){ const double _wynorm=1.0/(1ull<<52); return (r>>12)*_wynorm;}
+static inline double wy2gau(uint64_t r){ const double _wynorm=1.0/(1ull<<20); return ((r&0x1fffff)+((r>>21)&0x1fffff)+((r>>42)&0x1fffff))*_wynorm-3.0;}
+static inline uint64_t wy2u0k(uint64_t r, uint64_t k){ _wymum(&r,&k); return k; }
+
+static inline void make_secret(uint64_t seed, uint64_t *secret){
+  uint8_t c[] = {15, 23, 27, 29, 30, 39, 43, 45, 46, 51, 53, 54, 57, 58, 60, 71, 75, 77, 78, 83, 85, 86, 89, 90, 92, 99, 101, 102, 105, 106, 108, 113, 114, 116, 120, 135, 139, 141, 142, 147, 149, 150, 153, 154, 156, 163, 165, 166, 169, 170, 172, 177, 178, 180, 184, 195, 197, 198, 201, 202, 204, 209, 210, 212, 216, 225, 226, 228, 232, 240 };
+  for(size_t i=0;i<5;i++){
+    uint8_t ok;
+    do{
+      ok=1; secret[i]=0;
+      for(size_t j=0;j<64;j+=8) secret[i]|=((uint64_t)c[wyrand(&seed)%sizeof(c)])<<j;
+      if(secret[i]%2==0){ ok=0; continue; }
+      for(size_t j=0;j<i;j++)
+#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
+        if(__builtin_popcountll(secret[j]^secret[i])!=32){ ok=0; break; }
+#elif defined(_MSC_VER) && defined(_M_X64)
+        if(_mm_popcnt_u64(secret[j]^secret[i])!=32){ ok=0; break; }
+#endif
+       if(!ok)continue;
+       for(uint64_t j=3;j<0x100000000ull;j+=2) if(secret[i]%j==0){ ok=0; break; }
+    }while(!ok);
+  }
+}
+#endif

data/tests/basic.rb

@@ -216,7 +216,7 @@ module BasicTest
         m.map_string_int32 = {}
       end
 
-      assert_raise TypeError do
+      assert_raise Google::Protobuf::TypeError do
         m = MapMessage.new(:map_string_int32 => { 1 => "I am not a number" })
       end
     end
@@ -241,8 +241,12 @@ module BasicTest
         :map_string_msg => {"a" => TestMessage2.new(:foo => 1),
                             "b" => TestMessage2.new(:foo => 2)},
         :map_string_enum => {"a" => :A, "b" => :B})
-      expected = "<BasicTest::MapMessage: map_string_int32: {\"b\"=>2, \"a\"=>1}, map_string_msg: {\"b\"=><BasicTest::TestMessage2: foo: 2>, \"a\"=><BasicTest::TestMessage2: foo: 1>}, map_string_enum: {\"b\"=>:B, \"a\"=>:A}>"
-      assert_equal expected, m.inspect
+
+      # JRuby doesn't keep consistent ordering so check for either version
+      expected_a = "<BasicTest::MapMessage: map_string_int32: {\"b\"=>2, \"a\"=>1}, map_string_msg: {\"b\"=><BasicTest::TestMessage2: foo: 2>, \"a\"=><BasicTest::TestMessage2: foo: 1>}, map_string_enum: {\"b\"=>:B, \"a\"=>:A}>"
+      expected_b = "<BasicTest::MapMessage: map_string_int32: {\"a\"=>1, \"b\"=>2}, map_string_msg: {\"a\"=><BasicTest::TestMessage2: foo: 1>, \"b\"=><BasicTest::TestMessage2: foo: 2>}, map_string_enum: {\"a\"=>:A, \"b\"=>:B}>"
+      inspect_result = m.inspect
+      assert expected_a == inspect_result || expected_b == inspect_result, "Incorrect inspect result: #{inspect_result}"
     end
 
     def test_map_corruption
@@ -443,6 +447,7 @@ module BasicTest
         :optional_int32=>0,
         :optional_int64=>0,
         :optional_msg=>nil,
+        :optional_msg2=>nil,
         :optional_string=>"foo",
         :optional_uint32=>0,
         :optional_uint64=>0,
@@ -480,9 +485,9 @@ module BasicTest
       m = MapMessage.new(:map_string_int32 => {"a" => 1})
       expected = {mapStringInt32: {a: 1}, mapStringMsg: {}, mapStringEnum: {}}
       expected_preserve = {map_string_int32: {a: 1}, map_string_msg: {}, map_string_enum: {}}
-      assert_equal JSON.parse(MapMessage.encode_json(m), :symbolize_names => true), expected
+      assert_equal JSON.parse(MapMessage.encode_json(m, :emit_defaults=>true), :symbolize_names => true), expected
 
-      json = MapMessage.encode_json(m, :preserve_proto_fieldnames => true)
+      json = MapMessage.encode_json(m, :preserve_proto_fieldnames => true, :emit_defaults=>true)
       assert_equal JSON.parse(json, :symbolize_names => true), expected_preserve
 
       m2 = MapMessage.decode_json(MapMessage.encode_json(m))
@@ -492,7 +497,7 @@ module BasicTest
     def test_json_maps_emit_defaults_submsg
       # TODO: Fix JSON in JRuby version.
       return if RUBY_PLATFORM == "java"
-      m = MapMessage.new(:map_string_msg => {"a" => TestMessage2.new})
+      m = MapMessage.new(:map_string_msg => {"a" => TestMessage2.new(foo: 0)})
       expected = {mapStringInt32: {}, mapStringMsg: {a: {foo: 0}}, mapStringEnum: {}}
 
       actual = MapMessage.encode_json(m, :emit_defaults => true)
@@ -500,6 +505,30 @@ module BasicTest
       assert_equal JSON.parse(actual, :symbolize_names => true), expected
     end
 
+    def test_json_emit_defaults_submsg
+      # TODO: Fix JSON in JRuby version.
+      return if RUBY_PLATFORM == "java"
+      m = TestSingularFields.new(singular_msg: proto_module::TestMessage2.new)
+
+      expected = {
+        singularInt32: 0,
+        singularInt64: "0",
+        singularUint32: 0,
+        singularUint64: "0",
+        singularBool: false,
+        singularFloat: 0,
+        singularDouble: 0,
+        singularString: "",
+        singularBytes: "",
+        singularMsg: {},
+        singularEnum: "Default",
+      }
+
+      actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
+
+      assert_equal expected, JSON.parse(actual, :symbolize_names => true)
+    end
+
     def test_respond_to
       # This test fails with JRuby 1.7.23, likely because of an old JRuby bug.
       return if RUBY_PLATFORM == "java"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-protobuf
 version: !ruby/object:Gem::Version
-  version: 3.14.0
+  version: 3.15.0.rc.1
 platform: x86-linux
 authors:
 - Protobuf Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-13 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler-dock
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -84,23 +84,29 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ext/google/protobuf_c/convert.c
+- ext/google/protobuf_c/convert.h
 - ext/google/protobuf_c/defs.c
-- ext/google/protobuf_c/encode_decode.c
+- ext/google/protobuf_c/defs.h
 - ext/google/protobuf_c/extconf.rb
 - ext/google/protobuf_c/map.c
+- ext/google/protobuf_c/map.h
 - ext/google/protobuf_c/message.c
+- ext/google/protobuf_c/message.h
 - ext/google/protobuf_c/protobuf.c
 - ext/google/protobuf_c/protobuf.h
 - ext/google/protobuf_c/repeated_field.c
-- ext/google/protobuf_c/storage.c
-- ext/google/protobuf_c/upb.c
-- ext/google/protobuf_c/upb.h
+- ext/google/protobuf_c/repeated_field.h
+- ext/google/protobuf_c/ruby-upb.c
+- ext/google/protobuf_c/ruby-upb.h
+- ext/google/protobuf_c/third_party/wyhash/wyhash.h
 - ext/google/protobuf_c/wrap_memcpy.c
 - lib/google/2.3/protobuf_c.so
 - lib/google/2.4/protobuf_c.so
 - lib/google/2.5/protobuf_c.so
 - lib/google/2.6/protobuf_c.so
 - lib/google/2.7/protobuf_c.so
+- lib/google/3.0/protobuf_c.so
 - lib/google/protobuf.rb
 - lib/google/protobuf/any_pb.rb
 - lib/google/protobuf/api_pb.rb
@@ -122,7 +128,7 @@ homepage: https://developers.google.com/protocol-buffers
 licenses:
 - BSD-3-Clause
 metadata:
-  source_code_uri: https://github.com/protocolbuffers/protobuf/tree/v3.14.0/ruby
+  source_code_uri: https://github.com/protocolbuffers/protobuf/tree/v3.15.0-rc1/ruby
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -134,14 +140,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.3'
   - - "<"
     - !ruby/object:Gem::Version
-      version: 2.8.dev
+      version: 3.1.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Protocol Buffers

data/ext/google/protobuf_c/encode_decode.c

@@ -1,1795 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2014 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include "protobuf.h"
-
-VALUE initialize_rb_class_with_no_args(VALUE klass) {
-  return rb_funcall(klass, rb_intern("new"), 0);
-}
-
-// This function is equivalent to rb_str_cat(), but unlike the real
-// rb_str_cat(), it doesn't leak memory in some versions of Ruby.
-// For more information, see:
-//   https://bugs.ruby-lang.org/issues/11328
-VALUE noleak_rb_str_cat(VALUE rb_str, const char *str, long len) {
-  char *p;
-  size_t oldlen = RSTRING_LEN(rb_str);
-  rb_str_modify_expand(rb_str, len);
-  p = RSTRING_PTR(rb_str);
-  memcpy(p + oldlen, str, len);
-  rb_str_set_len(rb_str, oldlen + len);
-  return rb_str;
-}
-
-bool is_wrapper(const upb_msgdef* m) {
-  switch (upb_msgdef_wellknowntype(m)) {
-    case UPB_WELLKNOWN_DOUBLEVALUE:
-    case UPB_WELLKNOWN_FLOATVALUE:
-    case UPB_WELLKNOWN_INT64VALUE:
-    case UPB_WELLKNOWN_UINT64VALUE:
-    case UPB_WELLKNOWN_INT32VALUE:
-    case UPB_WELLKNOWN_UINT32VALUE:
-    case UPB_WELLKNOWN_STRINGVALUE:
-    case UPB_WELLKNOWN_BYTESVALUE:
-    case UPB_WELLKNOWN_BOOLVALUE:
-      return true;
-    default:
-      return false;
-  }
-}
-
-// The code below also comes from upb's prototype Ruby binding, developed by
-// haberman@.
-
-/* stringsink *****************************************************************/
-
-static void *stringsink_start(void *_sink, const void *hd, size_t size_hint) {
-  stringsink *sink = _sink;
-  sink->len = 0;
-  return sink;
-}
-
-static size_t stringsink_string(void *_sink, const void *hd, const char *ptr,
-                                size_t len, const upb_bufhandle *handle) {
-  stringsink *sink = _sink;
-  size_t new_size = sink->size;
-
-  UPB_UNUSED(hd);
-  UPB_UNUSED(handle);
-
-  while (sink->len + len > new_size) {
-    new_size *= 2;
-  }
-
-  if (new_size != sink->size) {
-    sink->ptr = realloc(sink->ptr, new_size);
-    sink->size = new_size;
-  }
-
-  memcpy(sink->ptr + sink->len, ptr, len);
-  sink->len += len;
-
-  return len;
-}
-
-void stringsink_init(stringsink *sink) {
-  upb_byteshandler_init(&sink->handler);
-  upb_byteshandler_setstartstr(&sink->handler, stringsink_start, NULL);
-  upb_byteshandler_setstring(&sink->handler, stringsink_string, NULL);
-
-  upb_bytessink_reset(&sink->sink, &sink->handler, sink);
-
-  sink->size = 32;
-  sink->ptr = malloc(sink->size);
-  sink->len = 0;
-}
-
-void stringsink_uninit(stringsink *sink) {
-  free(sink->ptr);
-}
-
-// -----------------------------------------------------------------------------
-// Parsing.
-// -----------------------------------------------------------------------------
-
-#define DEREF(msg, ofs, type) *(type*)(((uint8_t *)msg) + ofs)
-
-typedef struct {
-  size_t ofs;
-  int32_t hasbit;
-} field_handlerdata_t;
-
-// Creates a handlerdata that contains the offset and the hasbit for the field
-static const void* newhandlerdata(upb_handlers* h, uint32_t ofs, int32_t hasbit) {
-  field_handlerdata_t *hd = ALLOC(field_handlerdata_t);
-  hd->ofs = ofs;
-  hd->hasbit = hasbit;
-  upb_handlers_addcleanup(h, hd, xfree);
-  return hd;
-}
-
-typedef struct {
-  size_t ofs;
-  int32_t hasbit;
-  upb_fieldtype_t wrapped_type;  // Only for wrappers.
-  VALUE subklass;
-} submsg_handlerdata_t;
-
-// Creates a handlerdata that contains offset and submessage type information.
-static const void *newsubmsghandlerdata(upb_handlers* h,
-                                        const upb_fielddef *f,
-                                        uint32_t ofs,
-                                        int32_t hasbit,
-                                        VALUE subklass) {
-  submsg_handlerdata_t *hd = ALLOC(submsg_handlerdata_t);
-  const upb_msgdef *subm = upb_fielddef_msgsubdef(f);
-  hd->ofs = ofs;
-  hd->hasbit = hasbit;
-  hd->subklass = subklass;
-  upb_handlers_addcleanup(h, hd, xfree);
-  if (is_wrapper(subm)) {
-    const upb_fielddef *value_f = upb_msgdef_itof(subm, 1);
-    hd->wrapped_type = upb_fielddef_type(value_f);
-  }
-  return hd;
-}
-
-typedef struct {
-  size_t ofs;              // union data slot
-  size_t case_ofs;         // oneof_case field
-  uint32_t oneof_case_num; // oneof-case number to place in oneof_case field
-  VALUE subklass;
-} oneof_handlerdata_t;
-
-static const void *newoneofhandlerdata(upb_handlers *h,
-                                       uint32_t ofs,
-                                       uint32_t case_ofs,
-                                       const upb_fielddef *f,
-                                       const Descriptor* desc) {
-  oneof_handlerdata_t *hd = ALLOC(oneof_handlerdata_t);
-  hd->ofs = ofs;
-  hd->case_ofs = case_ofs;
-  // We reuse the field tag number as a oneof union discriminant tag. Note that
-  // we don't expose these numbers to the user, so the only requirement is that
-  // we have some unique ID for each union case/possibility. The field tag
-  // numbers are already present and are easy to use so there's no reason to
-  // create a separate ID space. In addition, using the field tag number here
-  // lets us easily look up the field in the oneof accessor.
-  hd->oneof_case_num = upb_fielddef_number(f);
-  if (is_value_field(f)) {
-    hd->oneof_case_num |= ONEOF_CASE_MASK;
-  }
-  hd->subklass = field_type_class(desc->layout, f);
-  upb_handlers_addcleanup(h, hd, xfree);
-  return hd;
-}
-
-// A handler that starts a repeated field.  Gets the Repeated*Field instance for
-// this field (such an instance always exists even in an empty message).
-static void *startseq_handler(void* closure, const void* hd) {
-  MessageHeader* msg = closure;
-  const size_t *ofs = hd;
-  return (void*)DEREF(msg, *ofs, VALUE);
-}
-
-// Handlers that append primitive values to a repeated field.
-#define DEFINE_APPEND_HANDLER(type, ctype)                 \
-  static bool append##type##_handler(void *closure, const void *hd, \
-                                     ctype val) {                   \
-    VALUE ary = (VALUE)closure;                                     \
-    RepeatedField_push_native(ary, &val);                           \
-    return true;                                                    \
-  }
-
-DEFINE_APPEND_HANDLER(bool,   bool)
-DEFINE_APPEND_HANDLER(int32,  int32_t)
-DEFINE_APPEND_HANDLER(uint32, uint32_t)
-DEFINE_APPEND_HANDLER(float,  float)
-DEFINE_APPEND_HANDLER(int64,  int64_t)
-DEFINE_APPEND_HANDLER(uint64, uint64_t)
-DEFINE_APPEND_HANDLER(double, double)
-
-// Appends a string to a repeated field.
-static void* appendstr_handler(void *closure,
-                               const void *hd,
-                               size_t size_hint) {
-  VALUE ary = (VALUE)closure;
-  VALUE str = rb_str_new2("");
-  rb_enc_associate(str, kRubyStringUtf8Encoding);
-  RepeatedField_push_native(ary, &str);
-  return (void*)str;
-}
-
-static void set_hasbit(void *closure, int32_t hasbit) {
-  if (hasbit > 0) {
-    uint8_t* storage = closure;
-    storage[hasbit/8] |= 1 << (hasbit % 8);
-  }
-}
-
-// Appends a 'bytes' string to a repeated field.
-static void* appendbytes_handler(void *closure,
-                                 const void *hd,
-                                 size_t size_hint) {
-  VALUE ary = (VALUE)closure;
-  VALUE str = rb_str_new2("");
-  rb_enc_associate(str, kRubyString8bitEncoding);
-  RepeatedField_push_native(ary, &str);
-  return (void*)str;
-}
-
-// Sets a non-repeated string field in a message.
-static void* str_handler(void *closure,
-                         const void *hd,
-                         size_t size_hint) {
-  MessageHeader* msg = closure;
-  const field_handlerdata_t *fieldhandler = hd;
-
-  VALUE str = rb_str_new2("");
-  rb_enc_associate(str, kRubyStringUtf8Encoding);
-  DEREF(msg, fieldhandler->ofs, VALUE) = str;
-  set_hasbit(closure, fieldhandler->hasbit);
-  return (void*)str;
-}
-
-// Sets a non-repeated 'bytes' field in a message.
-static void* bytes_handler(void *closure,
-                           const void *hd,
-                           size_t size_hint) {
-  MessageHeader* msg = closure;
-  const field_handlerdata_t *fieldhandler = hd;
-
-  VALUE str = rb_str_new2("");
-  rb_enc_associate(str, kRubyString8bitEncoding);
-  DEREF(msg, fieldhandler->ofs, VALUE) = str;
-  set_hasbit(closure, fieldhandler->hasbit);
-  return (void*)str;
-}
-
-static size_t stringdata_handler(void* closure, const void* hd,
-                                 const char* str, size_t len,
-                                 const upb_bufhandle* handle) {
-  VALUE rb_str = (VALUE)closure;
-  noleak_rb_str_cat(rb_str, str, len);
-  return len;
-}
-
-static bool stringdata_end_handler(void* closure, const void* hd) {
-  VALUE rb_str = (VALUE)closure;
-  rb_obj_freeze(rb_str);
-  return true;
-}
-
-static bool appendstring_end_handler(void* closure, const void* hd) {
-  VALUE rb_str = (VALUE)closure;
-  rb_obj_freeze(rb_str);
-  return true;
-}
-
-// Appends a submessage to a repeated field (a regular Ruby array for now).
-static void *appendsubmsg_handler(void *closure, const void *hd) {
-  VALUE ary = (VALUE)closure;
-  const submsg_handlerdata_t *submsgdata = hd;
-  MessageHeader* submsg;
-
-  VALUE submsg_rb = initialize_rb_class_with_no_args(submsgdata->subklass);
-  RepeatedField_push(ary, submsg_rb);
-
-  TypedData_Get_Struct(submsg_rb, MessageHeader, &Message_type, submsg);
-  return submsg;
-}
-
-// Appends a wrapper to a repeated field (a regular Ruby array for now).
-static void *appendwrapper_handler(void *closure, const void *hd) {
-  VALUE ary = (VALUE)closure;
-  int size = RepeatedField_size(ary);
-  (void)hd;
-
-  RepeatedField_push(ary, Qnil);
-
-  return RepeatedField_index_native(ary, size);
-}
-
-// Sets a non-repeated submessage field in a message.
-static void *submsg_handler(void *closure, const void *hd) {
-  MessageHeader* msg = closure;
-  const submsg_handlerdata_t* submsgdata = hd;
-  VALUE submsg_rb;
-  MessageHeader* submsg;
-
-  if (DEREF(msg, submsgdata->ofs, VALUE) == Qnil) {
-    DEREF(msg, submsgdata->ofs, VALUE) =
-        initialize_rb_class_with_no_args(submsgdata->subklass);
-  }
-
-  set_hasbit(closure, submsgdata->hasbit);
-
-  submsg_rb = DEREF(msg, submsgdata->ofs, VALUE);
-  TypedData_Get_Struct(submsg_rb, MessageHeader, &Message_type, submsg);
-
-  return submsg;
-}
-
-static void* startwrapper(void* closure, const void* hd) {
-  const submsg_handlerdata_t* submsgdata = hd;
-  char* msg = closure;
-  VALUE* field = (VALUE*)(msg + submsgdata->ofs);
-
-  set_hasbit(closure, submsgdata->hasbit);
-
-  switch (submsgdata->wrapped_type) {
-    case UPB_TYPE_FLOAT:
-    case UPB_TYPE_DOUBLE:
-      *field = DBL2NUM(0);
-      break;
-    case UPB_TYPE_BOOL:
-      *field = Qfalse;
-      break;
-    case UPB_TYPE_STRING:
-      *field = get_frozen_string(NULL, 0, false);
-      break;
-    case UPB_TYPE_BYTES:
-      *field = get_frozen_string(NULL, 0, true);
-      break;
-    case UPB_TYPE_ENUM:
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_UINT64:
-      *field = INT2NUM(0);
-      break;
-    case UPB_TYPE_MESSAGE:
-      rb_raise(rb_eRuntimeError,
-               "Internal logic error with well-known types.");
-  }
-
-  return field;
-}
-
-// Handler data for startmap/endmap handlers.
-typedef struct {
-  size_t ofs;
-  upb_fieldtype_t key_field_type;
-  upb_fieldtype_t value_field_type;
-  VALUE subklass;
-} map_handlerdata_t;
-
-// Temporary frame for map parsing: at the beginning of a map entry message, a
-// submsg handler allocates a frame to hold (i) a reference to the Map object
-// into which this message will be inserted and (ii) storage slots to
-// temporarily hold the key and value for this map entry until the end of the
-// submessage. When the submessage ends, another handler is called to insert the
-// value into the map.
-typedef struct {
-  VALUE map;
-  const map_handlerdata_t* handlerdata;
-  char key_storage[NATIVE_SLOT_MAX_SIZE];
-  char value_storage[NATIVE_SLOT_MAX_SIZE];
-} map_parse_frame_t;
-
-static void MapParseFrame_mark(void* _self) {
-  map_parse_frame_t* frame = _self;
-
-  // This shouldn't strictly be necessary since this should be rooted by the
-  // message itself, but it can't hurt.
-  rb_gc_mark(frame->map);
-
-  native_slot_mark(frame->handlerdata->key_field_type, &frame->key_storage);
-  native_slot_mark(frame->handlerdata->value_field_type, &frame->value_storage);
-}
-
-void MapParseFrame_free(void* self) {
-  xfree(self);
-}
-
-rb_data_type_t MapParseFrame_type = {
-  "MapParseFrame",
-  { MapParseFrame_mark, MapParseFrame_free, NULL },
-};
-
-// Handler to begin a map entry: allocates a temporary frame. This is the
-// 'startsubmsg' handler on the msgdef that contains the map field.
-static void *startmap_handler(void *closure, const void *hd) {
-  MessageHeader* msg = closure;
-  const map_handlerdata_t* mapdata = hd;
-  map_parse_frame_t* frame = ALLOC(map_parse_frame_t);
-  VALUE map_rb = DEREF(msg, mapdata->ofs, VALUE);
-
-  frame->handlerdata = mapdata;
-  frame->map = map_rb;
-  native_slot_init(mapdata->key_field_type, &frame->key_storage);
-  native_slot_init(mapdata->value_field_type, &frame->value_storage);
-
-  Map_set_frame(map_rb,
-                TypedData_Wrap_Struct(rb_cObject, &MapParseFrame_type, frame));
-
-  return frame;
-}
-
-static bool endmap_handler(void *closure, const void *hd) {
-  map_parse_frame_t* frame = closure;
-  Map_set_frame(frame->map, Qnil);
-  return true;
-}
-
-// Handler to end a map entry: inserts the value defined during the message into
-// the map. This is the 'endmsg' handler on the map entry msgdef.
-static bool endmapentry_handler(void* closure, const void* hd, upb_status* s) {
-  map_parse_frame_t* frame = closure;
-  const map_handlerdata_t* mapdata = hd;
-
-  VALUE key = native_slot_get(
-      mapdata->key_field_type, Qnil,
-      &frame->key_storage);
-
-  VALUE value = native_slot_get(
-      mapdata->value_field_type, mapdata->subklass,
-      &frame->value_storage);
-
-  Map_index_set(frame->map, key, value);
-
-  return true;
-}
-
-// Allocates a new map_handlerdata_t given the map entry message definition. If
-// the offset of the field within the parent message is also given, that is
-// added to the handler data as well. Note that this is called *twice* per map
-// field: once in the parent message handler setup when setting the startsubmsg
-// handler and once in the map entry message handler setup when setting the
-// key/value and endmsg handlers. The reason is that there is no easy way to
-// pass the handlerdata down to the sub-message handler setup.
-static map_handlerdata_t* new_map_handlerdata(
-    size_t ofs,
-    const upb_msgdef* mapentry_def,
-    const Descriptor* desc) {
-  const upb_fielddef* key_field;
-  const upb_fielddef* value_field;
-  map_handlerdata_t* hd = ALLOC(map_handlerdata_t);
-  hd->ofs = ofs;
-  key_field = upb_msgdef_itof(mapentry_def, MAP_KEY_FIELD);
-  assert(key_field != NULL);
-  hd->key_field_type = upb_fielddef_type(key_field);
-  value_field = upb_msgdef_itof(mapentry_def, MAP_VALUE_FIELD);
-  assert(value_field != NULL);
-  hd->value_field_type = upb_fielddef_type(value_field);
-  hd->subklass = field_type_class(desc->layout, value_field);
-
-  return hd;
-}
-
-// Handlers that set primitive values in oneofs.
-#define DEFINE_ONEOF_HANDLER(type, ctype)                           \
-  static bool oneof##type##_handler(void *closure, const void *hd,  \
-                                     ctype val) {                   \
-    const oneof_handlerdata_t *oneofdata = hd;                      \
-    DEREF(closure, oneofdata->case_ofs, uint32_t) =                 \
-        oneofdata->oneof_case_num;                                  \
-    DEREF(closure, oneofdata->ofs, ctype) = val;                    \
-    return true;                                                    \
-  }
-
-DEFINE_ONEOF_HANDLER(bool,   bool)
-DEFINE_ONEOF_HANDLER(int32,  int32_t)
-DEFINE_ONEOF_HANDLER(uint32, uint32_t)
-DEFINE_ONEOF_HANDLER(float,  float)
-DEFINE_ONEOF_HANDLER(int64,  int64_t)
-DEFINE_ONEOF_HANDLER(uint64, uint64_t)
-DEFINE_ONEOF_HANDLER(double, double)
-
-#undef DEFINE_ONEOF_HANDLER
-
-// Handlers for strings in a oneof.
-static void *oneofstr_handler(void *closure,
-                              const void *hd,
-                              size_t size_hint) {
-  MessageHeader* msg = closure;
-  const oneof_handlerdata_t *oneofdata = hd;
-  VALUE str = rb_str_new2("");
-  rb_enc_associate(str, kRubyStringUtf8Encoding);
-  DEREF(msg, oneofdata->case_ofs, uint32_t) =
-      oneofdata->oneof_case_num;
-  DEREF(msg, oneofdata->ofs, VALUE) = str;
-  return (void*)str;
-}
-
-static void *oneofbytes_handler(void *closure,
-                                const void *hd,
-                                size_t size_hint) {
-  MessageHeader* msg = closure;
-  const oneof_handlerdata_t *oneofdata = hd;
-  VALUE str = rb_str_new2("");
-  rb_enc_associate(str, kRubyString8bitEncoding);
-  DEREF(msg, oneofdata->case_ofs, uint32_t) =
-      oneofdata->oneof_case_num;
-  DEREF(msg, oneofdata->ofs, VALUE) = str;
-  return (void*)str;
-}
-
-static bool oneofstring_end_handler(void* closure, const void* hd) {
-  VALUE rb_str = rb_str_new2("");
-  rb_obj_freeze(rb_str);
-  return true;
-}
-
-// Handler for a submessage field in a oneof.
-static void *oneofsubmsg_handler(void *closure,
-                                 const void *hd) {
-  MessageHeader* msg = closure;
-  const oneof_handlerdata_t *oneofdata = hd;
-  uint32_t oldcase = DEREF(msg, oneofdata->case_ofs, uint32_t);
-
-  VALUE submsg_rb;
-  MessageHeader* submsg;
-
-  if (oldcase != oneofdata->oneof_case_num ||
-      DEREF(msg, oneofdata->ofs, VALUE) == Qnil) {
-    DEREF(msg, oneofdata->ofs, VALUE) =
-        initialize_rb_class_with_no_args(oneofdata->subklass);
-  }
-  // Set the oneof case *after* allocating the new class instance -- otherwise,
-  // if the Ruby GC is invoked as part of a call into the VM, it might invoke
-  // our mark routines, and our mark routines might see the case value
-  // indicating a VALUE is present and expect a valid VALUE. See comment in
-  // layout_set() for more detail: basically, the change to the value and the
-  // case must be atomic w.r.t. the Ruby VM.
-  DEREF(msg, oneofdata->case_ofs, uint32_t) = oneofdata->oneof_case_num;
-
-  submsg_rb = DEREF(msg, oneofdata->ofs, VALUE);
-  TypedData_Get_Struct(submsg_rb, MessageHeader, &Message_type, submsg);
-  return submsg;
-}
-
-static void* oneof_startwrapper(void* closure, const void* hd) {
-  char* msg = closure;
-  const oneof_handlerdata_t *oneofdata = hd;
-
-  DEREF(msg, oneofdata->case_ofs, uint32_t) = oneofdata->oneof_case_num;
-
-  return msg + oneofdata->ofs;
-}
-
-// Set up handlers for a repeated field.
-static void add_handlers_for_repeated_field(upb_handlers *h,
-                                            const Descriptor* desc,
-                                            const upb_fielddef *f,
-                                            size_t offset) {
-  upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-  attr.handler_data = newhandlerdata(h, offset, -1);
-  upb_handlers_setstartseq(h, f, startseq_handler, &attr);
-
-  switch (upb_fielddef_type(f)) {
-
-#define SET_HANDLER(utype, ltype)                                 \
-  case utype:                                                     \
-    upb_handlers_set##ltype(h, f, append##ltype##_handler, NULL); \
-    break;
-
-    SET_HANDLER(UPB_TYPE_BOOL,   bool);
-    SET_HANDLER(UPB_TYPE_INT32,  int32);
-    SET_HANDLER(UPB_TYPE_UINT32, uint32);
-    SET_HANDLER(UPB_TYPE_ENUM,   int32);
-    SET_HANDLER(UPB_TYPE_FLOAT,  float);
-    SET_HANDLER(UPB_TYPE_INT64,  int64);
-    SET_HANDLER(UPB_TYPE_UINT64, uint64);
-    SET_HANDLER(UPB_TYPE_DOUBLE, double);
-
-#undef SET_HANDLER
-
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES: {
-      bool is_bytes = upb_fielddef_type(f) == UPB_TYPE_BYTES;
-      upb_handlers_setstartstr(h, f, is_bytes ?
-                               appendbytes_handler : appendstr_handler,
-                               NULL);
-      upb_handlers_setstring(h, f, stringdata_handler, NULL);
-      upb_handlers_setendstr(h, f, appendstring_end_handler, NULL);
-      break;
-    }
-    case UPB_TYPE_MESSAGE: {
-      VALUE subklass = field_type_class(desc->layout, f);
-      upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-      attr.handler_data = newsubmsghandlerdata(h, f, 0, -1, subklass);
-      if (is_wrapper(upb_fielddef_msgsubdef(f))) {
-        upb_handlers_setstartsubmsg(h, f, appendwrapper_handler, &attr);
-      } else {
-        upb_handlers_setstartsubmsg(h, f, appendsubmsg_handler, &attr);
-      }
-      break;
-    }
-  }
-}
-
-static bool doublewrapper_handler(void* closure, const void* hd, double val) {
-  VALUE* rbval = closure;
-  *rbval = DBL2NUM(val);
-  return true;
-}
-
-static bool floatwrapper_handler(void* closure, const void* hd, float val) {
-  VALUE* rbval = closure;
-  *rbval = DBL2NUM(val);
-  return true;
-}
-
-static bool int64wrapper_handler(void* closure, const void* hd, int64_t val) {
-  VALUE* rbval = closure;
-  *rbval = LL2NUM(val);
-  return true;
-}
-
-static bool uint64wrapper_handler(void* closure, const void* hd, uint64_t val) {
-  VALUE* rbval = closure;
-  *rbval = ULL2NUM(val);
-  return true;
-}
-
-static bool int32wrapper_handler(void* closure, const void* hd, int32_t val) {
-  VALUE* rbval = closure;
-  *rbval = INT2NUM(val);
-  return true;
-}
-
-static bool uint32wrapper_handler(void* closure, const void* hd, uint32_t val) {
-  VALUE* rbval = closure;
-  *rbval = UINT2NUM(val);
-  return true;
-}
-
-static void* startstringwrapper_handler(void* closure, const void* hd,
-                                        size_t size_hint) {
-  VALUE* rbval = closure;
-  (void)size_hint;
-  *rbval = rb_str_new(NULL, 0);
-  rb_enc_associate(*rbval, kRubyStringUtf8Encoding);
-  return closure;
-}
-
-static size_t stringwrapper_handler(void* closure, const void* hd,
-                                    const char* ptr, size_t len,
-                                    const upb_bufhandle* handle) {
-  VALUE* rbval = closure;
-  *rbval = noleak_rb_str_cat(*rbval, ptr, len);
-  return len;
-}
-
-static void* startbyteswrapper_handler(void* closure, const void* hd,
-                                       size_t size_hint) {
-  VALUE* rbval = closure;
-  (void)size_hint;
-  *rbval = rb_str_new(NULL, 0);
-  rb_enc_associate(*rbval, kRubyString8bitEncoding);
-  return closure;
-}
-
-static size_t byteswrapper_handler(void* closure, const void* hd,
-                                   const char* ptr, size_t len,
-                                   const upb_bufhandle* handle) {
-  VALUE* rbval = closure;
-  *rbval = noleak_rb_str_cat(*rbval, ptr, len);
-  return len;
-}
-
-static bool boolwrapper_handler(void* closure, const void* hd, bool val) {
-  VALUE* rbval = closure;
-  if (val) {
-    *rbval = Qtrue;
-  } else {
-    *rbval = Qfalse;
-  }
-  return true;
-}
-
-// Set up handlers for a singular field.
-static void add_handlers_for_singular_field(const Descriptor* desc,
-                                            upb_handlers* h,
-                                            const upb_fielddef* f,
-                                            size_t offset, size_t hasbit_off) {
-  // The offset we pass to UPB points to the start of the Message,
-  // rather than the start of where our data is stored.
-  int32_t hasbit = -1;
-  if (hasbit_off != MESSAGE_FIELD_NO_HASBIT) {
-    hasbit = hasbit_off + sizeof(MessageHeader) * 8;
-  }
-
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_BOOL:
-    case UPB_TYPE_INT32:
-    case UPB_TYPE_UINT32:
-    case UPB_TYPE_ENUM:
-    case UPB_TYPE_FLOAT:
-    case UPB_TYPE_INT64:
-    case UPB_TYPE_UINT64:
-    case UPB_TYPE_DOUBLE:
-      upb_msg_setscalarhandler(h, f, offset, hasbit);
-      break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES: {
-      bool is_bytes = upb_fielddef_type(f) == UPB_TYPE_BYTES;
-      upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-      attr.handler_data = newhandlerdata(h, offset, hasbit);
-      upb_handlers_setstartstr(h, f,
-                               is_bytes ? bytes_handler : str_handler,
-                               &attr);
-      upb_handlers_setstring(h, f, stringdata_handler, &attr);
-      upb_handlers_setendstr(h, f, stringdata_end_handler, &attr);
-      break;
-    }
-    case UPB_TYPE_MESSAGE: {
-      upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-      attr.handler_data = newsubmsghandlerdata(
-          h, f, offset, hasbit, field_type_class(desc->layout, f));
-      if (is_wrapper(upb_fielddef_msgsubdef(f))) {
-        upb_handlers_setstartsubmsg(h, f, startwrapper, &attr);
-      } else {
-        upb_handlers_setstartsubmsg(h, f, submsg_handler, &attr);
-      }
-    }
-  }
-}
-
-// Adds handlers to a map field.
-static void add_handlers_for_mapfield(upb_handlers* h,
-                                      const upb_fielddef* fielddef,
-                                      size_t offset,
-                                      const Descriptor* desc) {
-  const upb_msgdef* map_msgdef = upb_fielddef_msgsubdef(fielddef);
-  map_handlerdata_t* hd = new_map_handlerdata(offset, map_msgdef, desc);
-  upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-
-  upb_handlers_addcleanup(h, hd, xfree);
-  attr.handler_data = hd;
-  upb_handlers_setstartsubmsg(h, fielddef, startmap_handler, &attr);
-  upb_handlers_setendsubmsg(h, fielddef, endmap_handler, &attr);
-}
-
-// Adds handlers to a map-entry msgdef.
-static void add_handlers_for_mapentry(const upb_msgdef* msgdef, upb_handlers* h,
-                                      const Descriptor* desc) {
-  const upb_fielddef* key_field = map_entry_key(msgdef);
-  const upb_fielddef* value_field = map_entry_value(msgdef);
-  map_handlerdata_t* hd = new_map_handlerdata(0, msgdef, desc);
-  upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-
-  upb_handlers_addcleanup(h, hd, xfree);
-  attr.handler_data = hd;
-  upb_handlers_setendmsg(h, endmapentry_handler, &attr);
-
-  add_handlers_for_singular_field(
-      desc, h, key_field,
-      offsetof(map_parse_frame_t, key_storage),
-      MESSAGE_FIELD_NO_HASBIT);
-  add_handlers_for_singular_field(
-      desc, h, value_field,
-      offsetof(map_parse_frame_t, value_storage),
-      MESSAGE_FIELD_NO_HASBIT);
-}
-
-static void add_handlers_for_wrapper(const upb_msgdef* msgdef,
-                                     upb_handlers* h) {
-  const upb_fielddef* f = upb_msgdef_itof(msgdef, 1);
-  switch (upb_msgdef_wellknowntype(msgdef)) {
-    case UPB_WELLKNOWN_DOUBLEVALUE:
-      upb_handlers_setdouble(h, f, doublewrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_FLOATVALUE:
-      upb_handlers_setfloat(h, f, floatwrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_INT64VALUE:
-      upb_handlers_setint64(h, f, int64wrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_UINT64VALUE:
-      upb_handlers_setuint64(h, f, uint64wrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_INT32VALUE:
-      upb_handlers_setint32(h, f, int32wrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_UINT32VALUE:
-      upb_handlers_setuint32(h, f, uint32wrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_STRINGVALUE:
-      upb_handlers_setstartstr(h, f, startstringwrapper_handler, NULL);
-      upb_handlers_setstring(h, f, stringwrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_BYTESVALUE:
-      upb_handlers_setstartstr(h, f, startbyteswrapper_handler, NULL);
-      upb_handlers_setstring(h, f, byteswrapper_handler, NULL);
-      break;
-    case UPB_WELLKNOWN_BOOLVALUE:
-      upb_handlers_setbool(h, f, boolwrapper_handler, NULL);
-      return;
-    default:
-      rb_raise(rb_eRuntimeError,
-               "Internal logic error with well-known types.");
-  }
-}
-
-// Set up handlers for a oneof field.
-static void add_handlers_for_oneof_field(upb_handlers *h,
-                                         const upb_fielddef *f,
-                                         size_t offset,
-                                         size_t oneof_case_offset,
-                                         const Descriptor* desc) {
-  upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-  attr.handler_data =
-      newoneofhandlerdata(h, offset, oneof_case_offset, f, desc);
-
-  switch (upb_fielddef_type(f)) {
-
-#define SET_HANDLER(utype, ltype)                                 \
-  case utype:                                                     \
-    upb_handlers_set##ltype(h, f, oneof##ltype##_handler, &attr); \
-    break;
-
-    SET_HANDLER(UPB_TYPE_BOOL,   bool);
-    SET_HANDLER(UPB_TYPE_INT32,  int32);
-    SET_HANDLER(UPB_TYPE_UINT32, uint32);
-    SET_HANDLER(UPB_TYPE_ENUM,   int32);
-    SET_HANDLER(UPB_TYPE_FLOAT,  float);
-    SET_HANDLER(UPB_TYPE_INT64,  int64);
-    SET_HANDLER(UPB_TYPE_UINT64, uint64);
-    SET_HANDLER(UPB_TYPE_DOUBLE, double);
-
-#undef SET_HANDLER
-
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES: {
-      bool is_bytes = upb_fielddef_type(f) == UPB_TYPE_BYTES;
-      upb_handlers_setstartstr(h, f, is_bytes ?
-                               oneofbytes_handler : oneofstr_handler,
-                               &attr);
-      upb_handlers_setstring(h, f, stringdata_handler, NULL);
-      upb_handlers_setendstr(h, f, oneofstring_end_handler, &attr);
-      break;
-    }
-    case UPB_TYPE_MESSAGE: {
-      if (is_wrapper(upb_fielddef_msgsubdef(f))) {
-        upb_handlers_setstartsubmsg(h, f, oneof_startwrapper, &attr);
-      } else {
-        upb_handlers_setstartsubmsg(h, f, oneofsubmsg_handler, &attr);
-      }
-      break;
-    }
-  }
-}
-
-static bool unknown_field_handler(void* closure, const void* hd,
-                                  const char* buf, size_t size) {
-  MessageHeader* msg = (MessageHeader*)closure;
-  UPB_UNUSED(hd);
-
-  if (msg->unknown_fields == NULL) {
-    msg->unknown_fields = malloc(sizeof(stringsink));
-    stringsink_init(msg->unknown_fields);
-  }
-
-  stringsink_string(msg->unknown_fields, NULL, buf, size, NULL);
-
-  return true;
-}
-
-size_t get_field_offset(MessageLayout* layout, const upb_fielddef* f) {
-  return layout->fields[upb_fielddef_index(f)].offset + sizeof(MessageHeader);
-}
-
-void add_handlers_for_message(const void *closure, upb_handlers *h) {
-  const VALUE descriptor_pool = (VALUE)closure;
-  const upb_msgdef* msgdef = upb_handlers_msgdef(h);
-  Descriptor* desc =
-      ruby_to_Descriptor(get_msgdef_obj(descriptor_pool, msgdef));
-  upb_msg_field_iter i;
-  upb_handlerattr attr = UPB_HANDLERATTR_INIT;
-
-  // Ensure layout exists. We may be invoked to create handlers for a given
-  // message if we are included as a submsg of another message type before our
-  // class is actually built, so to work around this, we just create the layout
-  // (and handlers, in the class-building function) on-demand.
-  if (desc->layout == NULL) {
-    create_layout(desc);
-  }
-
-  // If this is a mapentry message type, set up a special set of handlers and
-  // bail out of the normal (user-defined) message type handling.
-  if (upb_msgdef_mapentry(msgdef)) {
-    add_handlers_for_mapentry(msgdef, h, desc);
-    return;
-  }
-
-  // If this is a wrapper type, use special handlers and bail.
-  if (is_wrapper(msgdef)) {
-    add_handlers_for_wrapper(msgdef, h);
-    return;
-  }
-
-  upb_handlers_setunknown(h, unknown_field_handler, &attr);
-
-  for (upb_msg_field_begin(&i, desc->msgdef);
-       !upb_msg_field_done(&i);
-       upb_msg_field_next(&i)) {
-    const upb_fielddef *f = upb_msg_iter_field(&i);
-    const upb_oneofdef* oneof = upb_fielddef_realcontainingoneof(f);
-    size_t offset = get_field_offset(desc->layout, f);
-
-    if (oneof) {
-      size_t oneof_case_offset =
-          desc->layout->oneofs[upb_oneofdef_index(oneof)].case_offset +
-          sizeof(MessageHeader);
-      add_handlers_for_oneof_field(h, f, offset, oneof_case_offset, desc);
-    } else if (is_map_field(f)) {
-      add_handlers_for_mapfield(h, f, offset, desc);
-    } else if (upb_fielddef_isseq(f)) {
-      add_handlers_for_repeated_field(h, desc, f, offset);
-    } else {
-      add_handlers_for_singular_field(
-          desc, h, f, offset,
-          desc->layout->fields[upb_fielddef_index(f)].hasbit);
-    }
-  }
-}
-
-// Constructs the handlers for filling a message's data into an in-memory
-// object.
-const upb_handlers* get_fill_handlers(Descriptor* desc) {
-  DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
-  return upb_handlercache_get(pool->fill_handler_cache, desc->msgdef);
-}
-
-static const upb_pbdecodermethod *msgdef_decodermethod(Descriptor* desc) {
-  DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
-  return upb_pbcodecache_get(pool->fill_method_cache, desc->msgdef);
-}
-
-static const upb_json_parsermethod *msgdef_jsonparsermethod(Descriptor* desc) {
-  DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
-  return upb_json_codecache_get(pool->json_fill_method_cache, desc->msgdef);
-}
-
-static const upb_handlers* msgdef_pb_serialize_handlers(Descriptor* desc) {
-  DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
-  return upb_handlercache_get(pool->pb_serialize_handler_cache, desc->msgdef);
-}
-
-static const upb_handlers* msgdef_json_serialize_handlers(
-    Descriptor* desc, bool preserve_proto_fieldnames) {
-  DescriptorPool* pool = ruby_to_DescriptorPool(desc->descriptor_pool);
-  if (preserve_proto_fieldnames) {
-    return upb_handlercache_get(pool->json_serialize_handler_preserve_cache,
-                                desc->msgdef);
-  } else {
-    return upb_handlercache_get(pool->json_serialize_handler_cache,
-                                desc->msgdef);
-  }
-}
-
-
-// Stack-allocated context during an encode/decode operation. Contains the upb
-// environment and its stack-based allocator, an initial buffer for allocations
-// to avoid malloc() when possible, and a template for Ruby exception messages
-// if any error occurs.
-#define STACK_ENV_STACKBYTES 4096
-typedef struct {
-  upb_arena *arena;
-  upb_status status;
-  const char* ruby_error_template;
-  char allocbuf[STACK_ENV_STACKBYTES];
-} stackenv;
-
-static void stackenv_init(stackenv* se, const char* errmsg);
-static void stackenv_uninit(stackenv* se);
-
-static void stackenv_init(stackenv* se, const char* errmsg) {
-  se->ruby_error_template = errmsg;
-  se->arena =
-      upb_arena_init(se->allocbuf, sizeof(se->allocbuf), &upb_alloc_global);
-  upb_status_clear(&se->status);
-}
-
-static void stackenv_uninit(stackenv* se) {
-  upb_arena_free(se->arena);
-
-  if (!upb_ok(&se->status)) {
-    // TODO(haberman): have a way to verify that this is actually a parse error,
-    // instead of just throwing "parse error" unconditionally.
-    VALUE errmsg = rb_str_new2(upb_status_errmsg(&se->status));
-    rb_raise(cParseError, se->ruby_error_template, errmsg);
-  }
-}
-
-/*
- * call-seq:
- *     MessageClass.decode(data) => message
- *
- * Decodes the given data (as a string containing bytes in protocol buffers wire
- * format) under the interpretration given by this message class's definition
- * and returns a message object with the corresponding field values.
- */
-VALUE Message_decode(VALUE klass, VALUE data) {
-  VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
-  Descriptor* desc = ruby_to_Descriptor(descriptor);
-  VALUE msgklass = Descriptor_msgclass(descriptor);
-  VALUE msg_rb;
-  MessageHeader* msg;
-
-  if (TYPE(data) != T_STRING) {
-    rb_raise(rb_eArgError, "Expected string for binary protobuf data.");
-  }
-
-  msg_rb = initialize_rb_class_with_no_args(msgklass);
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-
-  {
-    const upb_pbdecodermethod* method = msgdef_decodermethod(desc);
-    const upb_handlers* h = upb_pbdecodermethod_desthandlers(method);
-    const upb_msgdef* m = upb_handlers_msgdef(h);
-    VALUE wrapper = Qnil;
-    void* ptr = msg;
-    stackenv se;
-    upb_sink sink;
-    upb_pbdecoder* decoder;
-    stackenv_init(&se, "Error occurred during parsing: %" PRIsVALUE);
-
-    if (is_wrapper(m)) {
-      ptr = &wrapper;
-    }
-
-    upb_sink_reset(&sink, h, ptr);
-    decoder = upb_pbdecoder_create(se.arena, method, sink, &se.status);
-    upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data),
-                      upb_pbdecoder_input(decoder));
-
-    stackenv_uninit(&se);
-
-    if (is_wrapper(m)) {
-      msg_rb = ruby_wrapper_type(msgklass, wrapper);
-    }
-  }
-
-  return msg_rb;
-}
-
-/*
- * call-seq:
- *     MessageClass.decode_json(data, options = {}) => message
- *
- * Decodes the given data (as a string containing bytes in protocol buffers wire
- * format) under the interpretration given by this message class's definition
- * and returns a message object with the corresponding field values.
- *
- *  @param options [Hash] options for the decoder
- *   ignore_unknown_fields: set true to ignore unknown fields (default is to
- *   raise an error)
- */
-VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
-  VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
-  Descriptor* desc = ruby_to_Descriptor(descriptor);
-  VALUE msgklass = Descriptor_msgclass(descriptor);
-  VALUE msg_rb;
-  VALUE data = argv[0];
-  VALUE ignore_unknown_fields = Qfalse;
-  MessageHeader* msg;
-
-  if (argc < 1 || argc > 2) {
-    rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
-  }
-
-  if (argc == 2) {
-    VALUE hash_args = argv[1];
-    if (TYPE(hash_args) != T_HASH) {
-      rb_raise(rb_eArgError, "Expected hash arguments.");
-    }
-
-    ignore_unknown_fields = rb_hash_lookup2(
-        hash_args, ID2SYM(rb_intern("ignore_unknown_fields")), Qfalse);
-  }
-
-  if (TYPE(data) != T_STRING) {
-    rb_raise(rb_eArgError, "Expected string for JSON data.");
-  }
-
-  // TODO(cfallin): Check and respect string encoding. If not UTF-8, we need to
-  // convert, because string handlers pass data directly to message string
-  // fields.
-
-  msg_rb = initialize_rb_class_with_no_args(msgklass);
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-
-  {
-    const upb_json_parsermethod* method = msgdef_jsonparsermethod(desc);
-    const upb_handlers* h = get_fill_handlers(desc);
-    const upb_msgdef* m = upb_handlers_msgdef(h);
-    stackenv se;
-    upb_sink sink;
-    upb_json_parser* parser;
-    DescriptorPool* pool = ruby_to_DescriptorPool(generated_pool);
-    stackenv_init(&se, "Error occurred during parsing: %" PRIsVALUE);
-
-    if (is_wrapper(m)) {
-      rb_raise(
-          rb_eRuntimeError,
-          "Parsing a wrapper type from JSON at the top level does not work.");
-    }
-
-    upb_sink_reset(&sink, h, msg);
-    parser = upb_json_parser_create(se.arena, method, pool->symtab, sink,
-                                    &se.status, RTEST(ignore_unknown_fields));
-    upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data),
-                      upb_json_parser_input(parser));
-
-    stackenv_uninit(&se);
-  }
-
-  return msg_rb;
-}
-
-// -----------------------------------------------------------------------------
-// Serializing.
-// -----------------------------------------------------------------------------
-
-/* msgvisitor *****************************************************************/
-
-static void putmsg(VALUE msg, const Descriptor* desc, upb_sink sink, int depth,
-                   bool emit_defaults, bool is_json, bool open_msg);
-
-static upb_selector_t getsel(const upb_fielddef *f, upb_handlertype_t type) {
-  upb_selector_t ret;
-  bool ok = upb_handlers_getselector(f, type, &ret);
-  UPB_ASSERT(ok);
-  return ret;
-}
-
-static void putstr(VALUE str, const upb_fielddef *f, upb_sink sink) {
-  upb_sink subsink;
-
-  if (str == Qnil) return;
-
-  assert(BUILTIN_TYPE(str) == RUBY_T_STRING);
-
-  // We should be guaranteed that the string has the correct encoding because
-  // we ensured this at assignment time and then froze the string.
-  if (upb_fielddef_type(f) == UPB_TYPE_STRING) {
-    assert(rb_enc_from_index(ENCODING_GET(str)) == kRubyStringUtf8Encoding);
-  } else {
-    assert(rb_enc_from_index(ENCODING_GET(str)) == kRubyString8bitEncoding);
-  }
-
-  upb_sink_startstr(sink, getsel(f, UPB_HANDLER_STARTSTR), RSTRING_LEN(str),
-                    &subsink);
-  upb_sink_putstring(subsink, getsel(f, UPB_HANDLER_STRING), RSTRING_PTR(str),
-                     RSTRING_LEN(str), NULL);
-  upb_sink_endstr(sink, getsel(f, UPB_HANDLER_ENDSTR));
-}
-
-static void putsubmsg(VALUE submsg, const upb_fielddef *f, upb_sink sink,
-                      int depth, bool emit_defaults, bool is_json) {
-  upb_sink subsink;
-  VALUE descriptor;
-  Descriptor* subdesc;
-
-  if (submsg == Qnil) return;
-
-  descriptor = rb_ivar_get(submsg, descriptor_instancevar_interned);
-  subdesc = ruby_to_Descriptor(descriptor);
-
-  upb_sink_startsubmsg(sink, getsel(f, UPB_HANDLER_STARTSUBMSG), &subsink);
-  putmsg(submsg, subdesc, subsink, depth + 1, emit_defaults, is_json, true);
-  upb_sink_endsubmsg(sink, subsink, getsel(f, UPB_HANDLER_ENDSUBMSG));
-}
-
-static void putary(VALUE ary, const upb_fielddef* f, upb_sink sink, int depth,
-                   bool emit_defaults, bool is_json) {
-  upb_sink subsink;
-  upb_fieldtype_t type = upb_fielddef_type(f);
-  upb_selector_t sel = 0;
-  int size;
-  int i;
-  VALUE type_class = ruby_to_RepeatedField(ary)->field_type_class;
-
-  if (ary == Qnil) return;
-  if (!emit_defaults && NUM2INT(RepeatedField_length(ary)) == 0) return;
-
-  size = NUM2INT(RepeatedField_length(ary));
-  if (size == 0 && !emit_defaults) return;
-
-  upb_sink_startseq(sink, getsel(f, UPB_HANDLER_STARTSEQ), &subsink);
-
-  if (upb_fielddef_isprimitive(f)) {
-    sel = getsel(f, upb_handlers_getprimitivehandlertype(f));
-  }
-
-  for (i = 0; i < size; i++) {
-    void* memory = RepeatedField_index_native(ary, i);
-    switch (type) {
-#define T(upbtypeconst, upbtype, ctype)                     \
-  case upbtypeconst:                                        \
-    upb_sink_put##upbtype(subsink, sel, *((ctype*)memory)); \
-    break;
-
-      T(UPB_TYPE_FLOAT,  float,  float)
-      T(UPB_TYPE_DOUBLE, double, double)
-      T(UPB_TYPE_BOOL,   bool,   int8_t)
-      case UPB_TYPE_ENUM:
-      T(UPB_TYPE_INT32,  int32,  int32_t)
-      T(UPB_TYPE_UINT32, uint32, uint32_t)
-      T(UPB_TYPE_INT64,  int64,  int64_t)
-      T(UPB_TYPE_UINT64, uint64, uint64_t)
-
-      case UPB_TYPE_STRING:
-      case UPB_TYPE_BYTES:
-        putstr(*((VALUE *)memory), f, subsink);
-        break;
-      case UPB_TYPE_MESSAGE: {
-        VALUE val = native_slot_get(UPB_TYPE_MESSAGE, type_class, memory);
-        putsubmsg(val, f, subsink, depth, emit_defaults, is_json);
-        break;
-      }
-
-#undef T
-
-    }
-  }
-  upb_sink_endseq(sink, getsel(f, UPB_HANDLER_ENDSEQ));
-}
-
-static void put_ruby_value(VALUE value, const upb_fielddef* f, VALUE type_class,
-                           int depth, upb_sink sink, bool emit_defaults,
-                           bool is_json) {
-  upb_selector_t sel = 0;
-
-  if (depth > ENCODE_MAX_NESTING) {
-    rb_raise(rb_eRuntimeError,
-             "Maximum recursion depth exceeded during encoding.");
-  }
-
-  if (upb_fielddef_isprimitive(f)) {
-    sel = getsel(f, upb_handlers_getprimitivehandlertype(f));
-  }
-
-  switch (upb_fielddef_type(f)) {
-    case UPB_TYPE_INT32:
-      upb_sink_putint32(sink, sel, NUM2INT(value));
-      break;
-    case UPB_TYPE_INT64:
-      upb_sink_putint64(sink, sel, NUM2LL(value));
-      break;
-    case UPB_TYPE_UINT32:
-      upb_sink_putuint32(sink, sel, NUM2UINT(value));
-      break;
-    case UPB_TYPE_UINT64:
-      upb_sink_putuint64(sink, sel, NUM2ULL(value));
-      break;
-    case UPB_TYPE_FLOAT:
-      upb_sink_putfloat(sink, sel, NUM2DBL(value));
-      break;
-    case UPB_TYPE_DOUBLE:
-      upb_sink_putdouble(sink, sel, NUM2DBL(value));
-      break;
-    case UPB_TYPE_ENUM: {
-      if (TYPE(value) == T_SYMBOL) {
-        value = rb_funcall(type_class, rb_intern("resolve"), 1, value);
-      }
-      upb_sink_putint32(sink, sel, NUM2INT(value));
-      break;
-    }
-    case UPB_TYPE_BOOL:
-      upb_sink_putbool(sink, sel, value == Qtrue);
-      break;
-    case UPB_TYPE_STRING:
-    case UPB_TYPE_BYTES:
-      putstr(value, f, sink);
-      break;
-    case UPB_TYPE_MESSAGE:
-      putsubmsg(value, f, sink, depth, emit_defaults, is_json);
-  }
-}
-
-static void putmap(VALUE map, const upb_fielddef* f, upb_sink sink, int depth,
-                   bool emit_defaults, bool is_json) {
-  Map* self;
-  upb_sink subsink;
-  const upb_fielddef* key_field;
-  const upb_fielddef* value_field;
-  Map_iter it;
-
-  if (map == Qnil) return;
-  if (!emit_defaults && Map_length(map) == 0) return;
-
-  self = ruby_to_Map(map);
-
-  upb_sink_startseq(sink, getsel(f, UPB_HANDLER_STARTSEQ), &subsink);
-
-  assert(upb_fielddef_type(f) == UPB_TYPE_MESSAGE);
-  key_field = map_field_key(f);
-  value_field = map_field_value(f);
-
-  for (Map_begin(map, &it); !Map_done(&it); Map_next(&it)) {
-    VALUE key = Map_iter_key(&it);
-    VALUE value = Map_iter_value(&it);
-    upb_status status;
-
-    upb_sink entry_sink;
-    upb_sink_startsubmsg(subsink, getsel(f, UPB_HANDLER_STARTSUBMSG),
-                         &entry_sink);
-    upb_sink_startmsg(entry_sink);
-
-    put_ruby_value(key, key_field, Qnil, depth + 1, entry_sink, emit_defaults,
-                   is_json);
-    put_ruby_value(value, value_field, self->value_type_class, depth + 1,
-                   entry_sink, emit_defaults, is_json);
-
-    upb_sink_endmsg(entry_sink, &status);
-    upb_sink_endsubmsg(subsink, entry_sink, getsel(f, UPB_HANDLER_ENDSUBMSG));
-  }
-
-  upb_sink_endseq(sink, getsel(f, UPB_HANDLER_ENDSEQ));
-}
-
-static const upb_handlers* msgdef_json_serialize_handlers(
-    Descriptor* desc, bool preserve_proto_fieldnames);
-
-static void putjsonany(VALUE msg_rb, const Descriptor* desc, upb_sink sink,
-                       int depth, bool emit_defaults) {
-  upb_status status;
-  MessageHeader* msg = NULL;
-  const upb_fielddef* type_field = upb_msgdef_itof(desc->msgdef, UPB_ANY_TYPE);
-  const upb_fielddef* value_field = upb_msgdef_itof(desc->msgdef, UPB_ANY_VALUE);
-
-  size_t type_url_offset;
-  VALUE type_url_str_rb;
-  const upb_msgdef *payload_type = NULL;
-
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-
-  upb_sink_startmsg(sink);
-
-  /* Handle type url */
-  type_url_offset = desc->layout->fields[upb_fielddef_index(type_field)].offset;
-  type_url_str_rb = DEREF(Message_data(msg), type_url_offset, VALUE);
-  if (RSTRING_LEN(type_url_str_rb) > 0) {
-    putstr(type_url_str_rb, type_field, sink);
-  }
-
-  {
-    const char* type_url_str = RSTRING_PTR(type_url_str_rb);
-    size_t type_url_len = RSTRING_LEN(type_url_str_rb);
-    DescriptorPool* pool = ruby_to_DescriptorPool(generated_pool);
-
-    if (type_url_len <= 20 ||
-        strncmp(type_url_str, "type.googleapis.com/", 20) != 0) {
-      rb_raise(rb_eRuntimeError, "Invalid type url: %s", type_url_str);
-      return;
-    }
-
-    /* Resolve type url */
-    type_url_str += 20;
-    type_url_len -= 20;
-
-    payload_type = upb_symtab_lookupmsg2(
-        pool->symtab, type_url_str, type_url_len);
-    if (payload_type == NULL) {
-      rb_raise(rb_eRuntimeError, "Unknown type: %s", type_url_str);
-      return;
-    }
-  }
-
-  {
-    uint32_t value_offset;
-    VALUE value_str_rb;
-    size_t value_len;
-
-    value_offset = desc->layout->fields[upb_fielddef_index(value_field)].offset;
-    value_str_rb = DEREF(Message_data(msg), value_offset, VALUE);
-    value_len = RSTRING_LEN(value_str_rb);
-
-    if (value_len > 0) {
-      VALUE payload_desc_rb = get_msgdef_obj(generated_pool, payload_type);
-      Descriptor* payload_desc = ruby_to_Descriptor(payload_desc_rb);
-      VALUE payload_class = Descriptor_msgclass(payload_desc_rb);
-      upb_sink subsink;
-      bool is_wellknown;
-
-      VALUE payload_msg_rb = Message_decode(payload_class, value_str_rb);
-
-      is_wellknown =
-          upb_msgdef_wellknowntype(payload_desc->msgdef) !=
-              UPB_WELLKNOWN_UNSPECIFIED;
-      if (is_wellknown) {
-        upb_sink_startstr(sink, getsel(value_field, UPB_HANDLER_STARTSTR), 0,
-                          &subsink);
-      }
-
-      subsink.handlers =
-          msgdef_json_serialize_handlers(payload_desc, true);
-      subsink.closure = sink.closure;
-      putmsg(payload_msg_rb, payload_desc, subsink, depth, emit_defaults, true,
-             is_wellknown);
-    }
-  }
-
-  upb_sink_endmsg(sink, &status);
-}
-
-static void putjsonlistvalue(
-    VALUE msg_rb, const Descriptor* desc,
-    upb_sink sink, int depth, bool emit_defaults) {
-  upb_status status;
-  upb_sink subsink;
-  MessageHeader* msg = NULL;
-  const upb_fielddef* f = upb_msgdef_itof(desc->msgdef, 1);
-  uint32_t offset =
-      desc->layout->fields[upb_fielddef_index(f)].offset +
-      sizeof(MessageHeader);
-  VALUE ary;
-
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-
-  upb_sink_startmsg(sink);
-
-  ary = DEREF(msg, offset, VALUE);
-
-  if (ary == Qnil || RepeatedField_size(ary) == 0) {
-    upb_sink_startseq(sink, getsel(f, UPB_HANDLER_STARTSEQ), &subsink);
-    upb_sink_endseq(sink, getsel(f, UPB_HANDLER_ENDSEQ));
-  } else {
-    putary(ary, f, sink, depth, emit_defaults, true);
-  }
-
-  upb_sink_endmsg(sink, &status);
-}
-
-static void putmsg(VALUE msg_rb, const Descriptor* desc,
-                   upb_sink sink, int depth, bool emit_defaults,
-                   bool is_json, bool open_msg) {
-  MessageHeader* msg;
-  upb_msg_field_iter i;
-  upb_status status;
-  bool json_wrapper = is_wrapper(desc->msgdef) && is_json;
-
-  if (is_json &&
-      upb_msgdef_wellknowntype(desc->msgdef) == UPB_WELLKNOWN_ANY) {
-    putjsonany(msg_rb, desc, sink, depth, emit_defaults);
-    return;
-  }
-
-  if (is_json &&
-      upb_msgdef_wellknowntype(desc->msgdef) == UPB_WELLKNOWN_LISTVALUE) {
-    putjsonlistvalue(msg_rb, desc, sink, depth, emit_defaults);
-    return;
-  }
-
-  if (open_msg) {
-    upb_sink_startmsg(sink);
-  }
-
-  // Protect against cycles (possible because users may freely reassign message
-  // and repeated fields) by imposing a maximum recursion depth.
-  if (depth > ENCODE_MAX_NESTING) {
-    rb_raise(rb_eRuntimeError,
-             "Maximum recursion depth exceeded during encoding.");
-  }
-
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-
-  if (desc != msg->descriptor) {
-    rb_raise(rb_eArgError,
-             "The type of given msg is '%s', expect '%s'.",
-             upb_msgdef_fullname(msg->descriptor->msgdef),
-             upb_msgdef_fullname(desc->msgdef));
-  }
-
-  for (upb_msg_field_begin(&i, desc->msgdef);
-       !upb_msg_field_done(&i);
-       upb_msg_field_next(&i)) {
-    upb_fielddef *f = upb_msg_iter_field(&i);
-    const upb_oneofdef* oneof = upb_fielddef_realcontainingoneof(f);
-    bool is_matching_oneof = false;
-    uint32_t offset =
-        desc->layout->fields[upb_fielddef_index(f)].offset +
-        sizeof(MessageHeader);
-
-    if (oneof) {
-      uint32_t oneof_case =
-          slot_read_oneof_case(desc->layout, Message_data(msg), oneof);
-      // For a oneof, check that this field is actually present -- skip all the
-      // below if not.
-      if (oneof_case != upb_fielddef_number(f)) {
-        continue;
-      }
-      // Otherwise, fall through to the appropriate singular-field handler
-      // below.
-      is_matching_oneof = true;
-    }
-
-    if (is_map_field(f)) {
-      VALUE map = DEREF(msg, offset, VALUE);
-      if (map != Qnil || emit_defaults) {
-        putmap(map, f, sink, depth, emit_defaults, is_json);
-      }
-    } else if (upb_fielddef_isseq(f)) {
-      VALUE ary = DEREF(msg, offset, VALUE);
-      if (ary != Qnil) {
-        putary(ary, f, sink, depth, emit_defaults, is_json);
-      }
-    } else if (upb_fielddef_isstring(f)) {
-      VALUE str = DEREF(msg, offset, VALUE);
-      bool is_default = false;
-
-      if (upb_msgdef_syntax(desc->msgdef) == UPB_SYNTAX_PROTO2) {
-        is_default = layout_has(desc->layout, Message_data(msg), f) == Qfalse;
-      } else if (upb_msgdef_syntax(desc->msgdef) == UPB_SYNTAX_PROTO3) {
-        is_default = RSTRING_LEN(str) == 0;
-      }
-
-      if (is_matching_oneof || emit_defaults || !is_default || json_wrapper) {
-        putstr(str, f, sink);
-      }
-    } else if (upb_fielddef_issubmsg(f)) {
-      // OPT: could try to avoid the layout_get() (which will expand lazy
-      // wrappers).
-      VALUE val = layout_get(desc->layout, Message_data(msg), f);
-      putsubmsg(val, f, sink, depth, emit_defaults, is_json);
-    } else {
-      upb_selector_t sel = getsel(f, upb_handlers_getprimitivehandlertype(f));
-
-#define T(upbtypeconst, upbtype, ctype, default_value)                       \
-  case upbtypeconst: {                                                       \
-    ctype value = DEREF(msg, offset, ctype);                                 \
-    bool is_default = false;                                                 \
-    if (upb_fielddef_haspresence(f)) {                                       \
-      is_default = layout_has(desc->layout, Message_data(msg), f) == Qfalse; \
-    } else if (upb_msgdef_syntax(desc->msgdef) == UPB_SYNTAX_PROTO3) {       \
-      is_default = default_value == value;                                   \
-    }                                                                        \
-    if (is_matching_oneof || emit_defaults || !is_default || json_wrapper) { \
-      upb_sink_put##upbtype(sink, sel, value);                               \
-    }                                                                        \
-  } break;
-
-      switch (upb_fielddef_type(f)) {
-        T(UPB_TYPE_FLOAT,  float,  float, 0.0)
-        T(UPB_TYPE_DOUBLE, double, double, 0.0)
-        T(UPB_TYPE_BOOL,   bool,   uint8_t, 0)
-        case UPB_TYPE_ENUM:
-        T(UPB_TYPE_INT32,  int32,  int32_t, 0)
-        T(UPB_TYPE_UINT32, uint32, uint32_t, 0)
-        T(UPB_TYPE_INT64,  int64,  int64_t, 0)
-        T(UPB_TYPE_UINT64, uint64, uint64_t, 0)
-
-        case UPB_TYPE_STRING:
-        case UPB_TYPE_BYTES:
-        case UPB_TYPE_MESSAGE: rb_raise(rb_eRuntimeError, "Internal error.");
-      }
-
-#undef T
-    }
-  }
-
-  {
-    stringsink* unknown = msg->unknown_fields;
-    if (unknown != NULL) {
-      upb_sink_putunknown(sink, unknown->ptr, unknown->len);
-    }
-  }
-
-  if (open_msg) {
-    upb_sink_endmsg(sink, &status);
-  }
-}
-
-/*
- * call-seq:
- *     MessageClass.encode(msg) => bytes
- *
- * Encodes the given message object to its serialized form in protocol buffers
- * wire format.
- */
-VALUE Message_encode(VALUE klass, VALUE msg_rb) {
-  VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
-  Descriptor* desc = ruby_to_Descriptor(descriptor);
-
-  stringsink sink;
-  stringsink_init(&sink);
-
-  {
-    const upb_handlers* serialize_handlers =
-        msgdef_pb_serialize_handlers(desc);
-
-    stackenv se;
-    upb_pb_encoder* encoder;
-    VALUE ret;
-
-    stackenv_init(&se, "Error occurred during encoding: %" PRIsVALUE);
-    encoder = upb_pb_encoder_create(se.arena, serialize_handlers, sink.sink);
-
-    putmsg(msg_rb, desc, upb_pb_encoder_input(encoder), 0, false, false, true);
-
-    ret = rb_str_new(sink.ptr, sink.len);
-
-    stackenv_uninit(&se);
-    stringsink_uninit(&sink);
-
-    return ret;
-  }
-}
-
-/*
- * call-seq:
- *     MessageClass.encode_json(msg, options = {}) => json_string
- *
- * Encodes the given message object into its serialized JSON representation.
- * @param options [Hash] options for the decoder
- *  preserve_proto_fieldnames: set true to use original fieldnames (default is to camelCase)
- *  emit_defaults: set true to emit 0/false values (default is to omit them)
- */
-VALUE Message_encode_json(int argc, VALUE* argv, VALUE klass) {
-  VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
-  Descriptor* desc = ruby_to_Descriptor(descriptor);
-  VALUE msg_rb;
-  VALUE preserve_proto_fieldnames = Qfalse;
-  VALUE emit_defaults = Qfalse;
-  stringsink sink;
-
-  if (argc < 1 || argc > 2) {
-    rb_raise(rb_eArgError, "Expected 1 or 2 arguments.");
-  }
-
-  msg_rb = argv[0];
-
-  if (argc == 2) {
-    VALUE hash_args = argv[1];
-    if (TYPE(hash_args) != T_HASH) {
-      rb_raise(rb_eArgError, "Expected hash arguments.");
-    }
-    preserve_proto_fieldnames = rb_hash_lookup2(
-        hash_args, ID2SYM(rb_intern("preserve_proto_fieldnames")), Qfalse);
-
-    emit_defaults = rb_hash_lookup2(
-        hash_args, ID2SYM(rb_intern("emit_defaults")), Qfalse);
-  }
-
-  stringsink_init(&sink);
-
-  {
-    const upb_handlers* serialize_handlers =
-        msgdef_json_serialize_handlers(desc, RTEST(preserve_proto_fieldnames));
-    upb_json_printer* printer;
-    stackenv se;
-    VALUE ret;
-
-    stackenv_init(&se, "Error occurred during encoding: %" PRIsVALUE);
-    printer = upb_json_printer_create(se.arena, serialize_handlers, sink.sink);
-
-    putmsg(msg_rb, desc, upb_json_printer_input(printer), 0,
-           RTEST(emit_defaults), true, true);
-
-    ret = rb_enc_str_new(sink.ptr, sink.len, rb_utf8_encoding());
-
-    stackenv_uninit(&se);
-    stringsink_uninit(&sink);
-
-    return ret;
-  }
-}
-
-static void discard_unknown(VALUE msg_rb, const Descriptor* desc) {
-  MessageHeader* msg;
-  upb_msg_field_iter it;
-
-  TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg);
-
-  {
-    stringsink* unknown = msg->unknown_fields;
-    if (unknown != NULL) {
-      stringsink_uninit(unknown);
-      msg->unknown_fields = NULL;
-    }
-  }
-
-  for (upb_msg_field_begin(&it, desc->msgdef);
-       !upb_msg_field_done(&it);
-       upb_msg_field_next(&it)) {
-    upb_fielddef *f = upb_msg_iter_field(&it);
-    const upb_oneofdef* oneof = upb_fielddef_realcontainingoneof(f);
-    uint32_t offset =
-        desc->layout->fields[upb_fielddef_index(f)].offset +
-        sizeof(MessageHeader);
-
-    if (oneof) {
-      uint32_t oneof_case =
-          slot_read_oneof_case(desc->layout, Message_data(msg), oneof);
-      // For a oneof, check that this field is actually present -- skip all the
-      // below if not.
-      if (oneof_case != upb_fielddef_number(f)) {
-        continue;
-      }
-      // Otherwise, fall through to the appropriate singular-field handler
-      // below.
-    }
-
-    if (!upb_fielddef_issubmsg(f)) {
-      continue;
-    }
-
-    if (is_map_field(f)) {
-      VALUE map;
-      Map_iter map_it;
-
-      if (!upb_fielddef_issubmsg(map_field_value(f))) continue;
-      map = DEREF(msg, offset, VALUE);
-      if (map == Qnil) continue;
-      for (Map_begin(map, &map_it); !Map_done(&map_it); Map_next(&map_it)) {
-        VALUE submsg = Map_iter_value(&map_it);
-        VALUE descriptor = rb_ivar_get(submsg, descriptor_instancevar_interned);
-        const Descriptor* subdesc = ruby_to_Descriptor(descriptor);
-        discard_unknown(submsg, subdesc);
-      }
-    } else if (upb_fielddef_isseq(f)) {
-      VALUE ary = DEREF(msg, offset, VALUE);
-      int size;
-      int i;
-
-      if (ary == Qnil) continue;
-      size = NUM2INT(RepeatedField_length(ary));
-      for (i = 0; i < size; i++) {
-        void* memory = RepeatedField_index_native(ary, i);
-        VALUE submsg = *((VALUE *)memory);
-        VALUE descriptor = rb_ivar_get(submsg, descriptor_instancevar_interned);
-        const Descriptor* subdesc = ruby_to_Descriptor(descriptor);
-        discard_unknown(submsg, subdesc);
-      }
-    } else {
-      VALUE submsg = DEREF(msg, offset, VALUE);
-      VALUE descriptor;
-      const Descriptor* subdesc;
-
-      if (submsg == Qnil) continue;
-      descriptor = rb_ivar_get(submsg, descriptor_instancevar_interned);
-      subdesc = ruby_to_Descriptor(descriptor);
-      discard_unknown(submsg, subdesc);
-    }
-  }
-}
-
-/*
- * call-seq:
- *     Google::Protobuf.discard_unknown(msg)
- *
- * Discard unknown fields in the given message object and recursively discard
- * unknown fields in submessages.
- */
-VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb) {
-  VALUE klass = CLASS_OF(msg_rb);
-  VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned);
-  Descriptor* desc = ruby_to_Descriptor(descriptor);
-  if (klass == cRepeatedField || klass == cMap) {
-    rb_raise(rb_eArgError, "Expected proto msg for discard unknown.");
-  } else {
-    discard_unknown(msg_rb, desc);
-  }
-  return Qnil;
-}