grpc 1.40.0 → 1.41.0.pre2

data/src/core/ext/upb-generated/validate/validate.upb.h

@@ -9,7 +9,7 @@
 #ifndef VALIDATE_VALIDATE_PROTO_UPB_H_
 #define VALIDATE_VALIDATE_PROTO_UPB_H_
 
-#include "upb/msg.h"
+#include "upb/msg_internal.h"
 #include "upb/decode.h"
 #include "upb/decode_fast.h"
 #include "upb/encode.h"
@@ -109,13 +109,19 @@ UPB_INLINE validate_FieldRules *validate_FieldRules_new(upb_arena *arena) {
 UPB_INLINE validate_FieldRules *validate_FieldRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_FieldRules *ret = validate_FieldRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_FieldRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_FieldRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_FieldRules *validate_FieldRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_FieldRules *ret = validate_FieldRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_FieldRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_FieldRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_FieldRules_serialize(const validate_FieldRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_FieldRules_msginit, arena, len);
@@ -466,13 +472,19 @@ UPB_INLINE validate_FloatRules *validate_FloatRules_new(upb_arena *arena) {
 UPB_INLINE validate_FloatRules *validate_FloatRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_FloatRules *ret = validate_FloatRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_FloatRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_FloatRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_FloatRules *validate_FloatRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_FloatRules *ret = validate_FloatRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_FloatRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_FloatRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_FloatRules_serialize(const validate_FloatRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_FloatRules_msginit, arena, len);
@@ -546,13 +558,19 @@ UPB_INLINE validate_DoubleRules *validate_DoubleRules_new(upb_arena *arena) {
 UPB_INLINE validate_DoubleRules *validate_DoubleRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_DoubleRules *ret = validate_DoubleRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_DoubleRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_DoubleRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_DoubleRules *validate_DoubleRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_DoubleRules *ret = validate_DoubleRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_DoubleRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_DoubleRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_DoubleRules_serialize(const validate_DoubleRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_DoubleRules_msginit, arena, len);
@@ -626,13 +644,19 @@ UPB_INLINE validate_Int32Rules *validate_Int32Rules_new(upb_arena *arena) {
 UPB_INLINE validate_Int32Rules *validate_Int32Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_Int32Rules *ret = validate_Int32Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_Int32Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_Int32Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_Int32Rules *validate_Int32Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_Int32Rules *ret = validate_Int32Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_Int32Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_Int32Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_Int32Rules_serialize(const validate_Int32Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_Int32Rules_msginit, arena, len);
@@ -706,13 +730,19 @@ UPB_INLINE validate_Int64Rules *validate_Int64Rules_new(upb_arena *arena) {
 UPB_INLINE validate_Int64Rules *validate_Int64Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_Int64Rules *ret = validate_Int64Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_Int64Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_Int64Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_Int64Rules *validate_Int64Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_Int64Rules *ret = validate_Int64Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_Int64Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_Int64Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_Int64Rules_serialize(const validate_Int64Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_Int64Rules_msginit, arena, len);
@@ -786,13 +816,19 @@ UPB_INLINE validate_UInt32Rules *validate_UInt32Rules_new(upb_arena *arena) {
 UPB_INLINE validate_UInt32Rules *validate_UInt32Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_UInt32Rules *ret = validate_UInt32Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_UInt32Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_UInt32Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_UInt32Rules *validate_UInt32Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_UInt32Rules *ret = validate_UInt32Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_UInt32Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_UInt32Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_UInt32Rules_serialize(const validate_UInt32Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_UInt32Rules_msginit, arena, len);
@@ -866,13 +902,19 @@ UPB_INLINE validate_UInt64Rules *validate_UInt64Rules_new(upb_arena *arena) {
 UPB_INLINE validate_UInt64Rules *validate_UInt64Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_UInt64Rules *ret = validate_UInt64Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_UInt64Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_UInt64Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_UInt64Rules *validate_UInt64Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_UInt64Rules *ret = validate_UInt64Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_UInt64Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_UInt64Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_UInt64Rules_serialize(const validate_UInt64Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_UInt64Rules_msginit, arena, len);
@@ -946,13 +988,19 @@ UPB_INLINE validate_SInt32Rules *validate_SInt32Rules_new(upb_arena *arena) {
 UPB_INLINE validate_SInt32Rules *validate_SInt32Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_SInt32Rules *ret = validate_SInt32Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_SInt32Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_SInt32Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_SInt32Rules *validate_SInt32Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_SInt32Rules *ret = validate_SInt32Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_SInt32Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_SInt32Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_SInt32Rules_serialize(const validate_SInt32Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_SInt32Rules_msginit, arena, len);
@@ -1026,13 +1074,19 @@ UPB_INLINE validate_SInt64Rules *validate_SInt64Rules_new(upb_arena *arena) {
 UPB_INLINE validate_SInt64Rules *validate_SInt64Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_SInt64Rules *ret = validate_SInt64Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_SInt64Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_SInt64Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_SInt64Rules *validate_SInt64Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_SInt64Rules *ret = validate_SInt64Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_SInt64Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_SInt64Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_SInt64Rules_serialize(const validate_SInt64Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_SInt64Rules_msginit, arena, len);
@@ -1106,13 +1160,19 @@ UPB_INLINE validate_Fixed32Rules *validate_Fixed32Rules_new(upb_arena *arena) {
 UPB_INLINE validate_Fixed32Rules *validate_Fixed32Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_Fixed32Rules *ret = validate_Fixed32Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_Fixed32Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_Fixed32Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_Fixed32Rules *validate_Fixed32Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_Fixed32Rules *ret = validate_Fixed32Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_Fixed32Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_Fixed32Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_Fixed32Rules_serialize(const validate_Fixed32Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_Fixed32Rules_msginit, arena, len);
@@ -1186,13 +1246,19 @@ UPB_INLINE validate_Fixed64Rules *validate_Fixed64Rules_new(upb_arena *arena) {
 UPB_INLINE validate_Fixed64Rules *validate_Fixed64Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_Fixed64Rules *ret = validate_Fixed64Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_Fixed64Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_Fixed64Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_Fixed64Rules *validate_Fixed64Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_Fixed64Rules *ret = validate_Fixed64Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_Fixed64Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_Fixed64Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_Fixed64Rules_serialize(const validate_Fixed64Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_Fixed64Rules_msginit, arena, len);
@@ -1266,13 +1332,19 @@ UPB_INLINE validate_SFixed32Rules *validate_SFixed32Rules_new(upb_arena *arena)
 UPB_INLINE validate_SFixed32Rules *validate_SFixed32Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_SFixed32Rules *ret = validate_SFixed32Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_SFixed32Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_SFixed32Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_SFixed32Rules *validate_SFixed32Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_SFixed32Rules *ret = validate_SFixed32Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_SFixed32Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_SFixed32Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_SFixed32Rules_serialize(const validate_SFixed32Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_SFixed32Rules_msginit, arena, len);
@@ -1346,13 +1418,19 @@ UPB_INLINE validate_SFixed64Rules *validate_SFixed64Rules_new(upb_arena *arena)
 UPB_INLINE validate_SFixed64Rules *validate_SFixed64Rules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_SFixed64Rules *ret = validate_SFixed64Rules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_SFixed64Rules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_SFixed64Rules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_SFixed64Rules *validate_SFixed64Rules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_SFixed64Rules *ret = validate_SFixed64Rules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_SFixed64Rules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_SFixed64Rules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_SFixed64Rules_serialize(const validate_SFixed64Rules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_SFixed64Rules_msginit, arena, len);
@@ -1426,13 +1504,19 @@ UPB_INLINE validate_BoolRules *validate_BoolRules_new(upb_arena *arena) {
 UPB_INLINE validate_BoolRules *validate_BoolRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_BoolRules *ret = validate_BoolRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_BoolRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_BoolRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_BoolRules *validate_BoolRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_BoolRules *ret = validate_BoolRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_BoolRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_BoolRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_BoolRules_serialize(const validate_BoolRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_BoolRules_msginit, arena, len);
@@ -1454,13 +1538,19 @@ UPB_INLINE validate_StringRules *validate_StringRules_new(upb_arena *arena) {
 UPB_INLINE validate_StringRules *validate_StringRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_StringRules *ret = validate_StringRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_StringRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_StringRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_StringRules *validate_StringRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_StringRules *ret = validate_StringRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_StringRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_StringRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_StringRules_serialize(const validate_StringRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_StringRules_msginit, arena, len);
@@ -1647,13 +1737,19 @@ UPB_INLINE validate_BytesRules *validate_BytesRules_new(upb_arena *arena) {
 UPB_INLINE validate_BytesRules *validate_BytesRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_BytesRules *ret = validate_BytesRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_BytesRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_BytesRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_BytesRules *validate_BytesRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_BytesRules *ret = validate_BytesRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_BytesRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_BytesRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_BytesRules_serialize(const validate_BytesRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_BytesRules_msginit, arena, len);
@@ -1768,13 +1864,19 @@ UPB_INLINE validate_EnumRules *validate_EnumRules_new(upb_arena *arena) {
 UPB_INLINE validate_EnumRules *validate_EnumRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_EnumRules *ret = validate_EnumRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_EnumRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_EnumRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_EnumRules *validate_EnumRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_EnumRules *ret = validate_EnumRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_EnumRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_EnumRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_EnumRules_serialize(const validate_EnumRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_EnumRules_msginit, arena, len);
@@ -1824,13 +1926,19 @@ UPB_INLINE validate_MessageRules *validate_MessageRules_new(upb_arena *arena) {
 UPB_INLINE validate_MessageRules *validate_MessageRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_MessageRules *ret = validate_MessageRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_MessageRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_MessageRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_MessageRules *validate_MessageRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_MessageRules *ret = validate_MessageRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_MessageRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_MessageRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_MessageRules_serialize(const validate_MessageRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_MessageRules_msginit, arena, len);
@@ -1858,13 +1966,19 @@ UPB_INLINE validate_RepeatedRules *validate_RepeatedRules_new(upb_arena *arena)
 UPB_INLINE validate_RepeatedRules *validate_RepeatedRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_RepeatedRules *ret = validate_RepeatedRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_RepeatedRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_RepeatedRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_RepeatedRules *validate_RepeatedRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_RepeatedRules *ret = validate_RepeatedRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_RepeatedRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_RepeatedRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_RepeatedRules_serialize(const validate_RepeatedRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_RepeatedRules_msginit, arena, len);
@@ -1919,13 +2033,19 @@ UPB_INLINE validate_MapRules *validate_MapRules_new(upb_arena *arena) {
 UPB_INLINE validate_MapRules *validate_MapRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_MapRules *ret = validate_MapRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_MapRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_MapRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_MapRules *validate_MapRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_MapRules *ret = validate_MapRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_MapRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_MapRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_MapRules_serialize(const validate_MapRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_MapRules_msginit, arena, len);
@@ -1995,13 +2115,19 @@ UPB_INLINE validate_AnyRules *validate_AnyRules_new(upb_arena *arena) {
 UPB_INLINE validate_AnyRules *validate_AnyRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_AnyRules *ret = validate_AnyRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_AnyRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_AnyRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_AnyRules *validate_AnyRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_AnyRules *ret = validate_AnyRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_AnyRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_AnyRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_AnyRules_serialize(const validate_AnyRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_AnyRules_msginit, arena, len);
@@ -2045,13 +2171,19 @@ UPB_INLINE validate_DurationRules *validate_DurationRules_new(upb_arena *arena)
 UPB_INLINE validate_DurationRules *validate_DurationRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_DurationRules *ret = validate_DurationRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_DurationRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_DurationRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_DurationRules *validate_DurationRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_DurationRules *ret = validate_DurationRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_DurationRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_DurationRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_DurationRules_serialize(const validate_DurationRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_DurationRules_msginit, arena, len);
@@ -2178,13 +2310,19 @@ UPB_INLINE validate_TimestampRules *validate_TimestampRules_new(upb_arena *arena
 UPB_INLINE validate_TimestampRules *validate_TimestampRules_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   validate_TimestampRules *ret = validate_TimestampRules_new(arena);
-  return (ret && upb_decode(buf, size, ret, &validate_TimestampRules_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &validate_TimestampRules_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE validate_TimestampRules *validate_TimestampRules_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   validate_TimestampRules *ret = validate_TimestampRules_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &validate_TimestampRules_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &validate_TimestampRules_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *validate_TimestampRules_serialize(const validate_TimestampRules *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &validate_TimestampRules_msginit, arena, len);

data/src/core/ext/upb-generated/xds/core/v3/authority.upb.c

@@ -7,7 +7,7 @@
  * regenerated. */
 
 #include <stddef.h>
-#include "upb/msg.h"
+#include "upb/msg_internal.h"
 #include "xds/core/v3/authority.upb.h"
 #include "udpa/annotations/status.upb.h"
 #include "validate/validate.upb.h"
@@ -15,13 +15,13 @@
 #include "upb/port_def.inc"
 
 static const upb_msglayout_field xds_core_v3_Authority__fields[1] = {
-  {1, UPB_SIZE(0, 0), 0, 0, 9, 1},
+  {1, UPB_SIZE(0, 0), 0, 0, 9, _UPB_MODE_SCALAR},
 };
 
 const upb_msglayout xds_core_v3_Authority_msginit = {
   NULL,
   &xds_core_v3_Authority__fields[0],
-  UPB_SIZE(8, 16), 1, false, 255,
+  UPB_SIZE(8, 16), 1, false, 1, 255,
 };
 
 #include "upb/port_undef.inc"

data/src/core/ext/upb-generated/xds/core/v3/authority.upb.h

@@ -9,7 +9,7 @@
 #ifndef XDS_CORE_V3_AUTHORITY_PROTO_UPB_H_
 #define XDS_CORE_V3_AUTHORITY_PROTO_UPB_H_
 
-#include "upb/msg.h"
+#include "upb/msg_internal.h"
 #include "upb/decode.h"
 #include "upb/decode_fast.h"
 #include "upb/encode.h"
@@ -33,13 +33,19 @@ UPB_INLINE xds_core_v3_Authority *xds_core_v3_Authority_new(upb_arena *arena) {
 UPB_INLINE xds_core_v3_Authority *xds_core_v3_Authority_parse(const char *buf, size_t size,
                         upb_arena *arena) {
   xds_core_v3_Authority *ret = xds_core_v3_Authority_new(arena);
-  return (ret && upb_decode(buf, size, ret, &xds_core_v3_Authority_msginit, arena)) ? ret : NULL;
+  if (!ret) return NULL;
+  if (!upb_decode(buf, size, ret, &xds_core_v3_Authority_msginit, arena)) return NULL;
+  return ret;
 }
 UPB_INLINE xds_core_v3_Authority *xds_core_v3_Authority_parse_ex(const char *buf, size_t size,
-                           upb_arena *arena, int options) {
+                           const upb_extreg *extreg, int options,
+                           upb_arena *arena) {
   xds_core_v3_Authority *ret = xds_core_v3_Authority_new(arena);
-  return (ret && _upb_decode(buf, size, ret, &xds_core_v3_Authority_msginit, arena, options))
-      ? ret : NULL;
+  if (!ret) return NULL;
+  if (!_upb_decode(buf, size, ret, &xds_core_v3_Authority_msginit, extreg, options, arena)) {
+    return NULL;
+  }
+  return ret;
 }
 UPB_INLINE char *xds_core_v3_Authority_serialize(const xds_core_v3_Authority *msg, upb_arena *arena, size_t *len) {
   return upb_encode(msg, &xds_core_v3_Authority_msginit, arena, len);