grpc 1.58.0 → 1.59.0

data/third_party/upb/upb/mini_table/{field_internal.h → internal/field.h}

@@ -25,11 +25,10 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef UPB_MINI_TABLE_FIELD_INTERNAL_H_
-#define UPB_MINI_TABLE_FIELD_INTERNAL_H_
+#ifndef UPB_MINI_TABLE_INTERNAL_FIELD_H_
+#define UPB_MINI_TABLE_INTERNAL_FIELD_H_
 
 #include "upb/base/descriptor_constants.h"
-#include "upb/mini_table/types.h"
 
 // Must be last.
 #include "upb/port/def.inc"
@@ -91,7 +90,7 @@ typedef enum {
 // LINT.ThenChange(//depot/google3/third_party/upb/js/impl/upb_bits/mini_table_field.ts:mini_table_field_layout)
 
 UPB_INLINE upb_FieldRep
-_upb_MiniTableField_GetRep(const upb_MiniTableField* field) {
+_upb_MiniTableField_GetRep(const struct upb_MiniTableField* field) {
   return (upb_FieldRep)(field->mode >> kUpb_FieldRep_Shift);
 }
 
@@ -99,94 +98,39 @@ _upb_MiniTableField_GetRep(const upb_MiniTableField* field) {
 extern "C" {
 #endif
 
-UPB_INLINE upb_FieldMode upb_FieldMode_Get(const upb_MiniTableField* field) {
+UPB_INLINE upb_FieldMode
+upb_FieldMode_Get(const struct upb_MiniTableField* field) {
   return (upb_FieldMode)(field->mode & 3);
 }
 
 UPB_INLINE void _upb_MiniTableField_CheckIsArray(
-    const upb_MiniTableField* field) {
+    const struct upb_MiniTableField* field) {
   UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_NativePointer);
   UPB_ASSUME(upb_FieldMode_Get(field) == kUpb_FieldMode_Array);
   UPB_ASSUME(field->presence == 0);
 }
 
 UPB_INLINE void _upb_MiniTableField_CheckIsMap(
-    const upb_MiniTableField* field) {
+    const struct upb_MiniTableField* field) {
   UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_NativePointer);
   UPB_ASSUME(upb_FieldMode_Get(field) == kUpb_FieldMode_Map);
   UPB_ASSUME(field->presence == 0);
 }
 
-UPB_INLINE bool upb_IsRepeatedOrMap(const upb_MiniTableField* field) {
+UPB_INLINE bool upb_IsRepeatedOrMap(const struct upb_MiniTableField* field) {
   // This works because upb_FieldMode has no value 3.
   return !(field->mode & kUpb_FieldMode_Scalar);
 }
 
-UPB_INLINE bool upb_IsSubMessage(const upb_MiniTableField* field) {
+UPB_INLINE bool upb_IsSubMessage(const struct upb_MiniTableField* field) {
   return field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Message ||
          field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group;
 }
 
-// LINT.IfChange(presence_logic)
-
-// Hasbit access ///////////////////////////////////////////////////////////////
-
-UPB_INLINE size_t _upb_hasbit_ofs(size_t idx) { return idx / 8; }
-
-UPB_INLINE char _upb_hasbit_mask(size_t idx) { return 1 << (idx % 8); }
-
-UPB_INLINE bool _upb_hasbit(const upb_Message* msg, size_t idx) {
-  return (*UPB_PTR_AT(msg, _upb_hasbit_ofs(idx), const char) &
-          _upb_hasbit_mask(idx)) != 0;
-}
-
-UPB_INLINE void _upb_sethas(const upb_Message* msg, size_t idx) {
-  (*UPB_PTR_AT(msg, _upb_hasbit_ofs(idx), char)) |= _upb_hasbit_mask(idx);
-}
-
-UPB_INLINE void _upb_clearhas(const upb_Message* msg, size_t idx) {
-  (*UPB_PTR_AT(msg, _upb_hasbit_ofs(idx), char)) &= ~_upb_hasbit_mask(idx);
-}
-
-UPB_INLINE size_t _upb_Message_Hasidx(const upb_MiniTableField* f) {
-  UPB_ASSERT(f->presence > 0);
-  return f->presence;
-}
-
-UPB_INLINE bool _upb_hasbit_field(const upb_Message* msg,
-                                  const upb_MiniTableField* f) {
-  return _upb_hasbit(msg, _upb_Message_Hasidx(f));
-}
-
-UPB_INLINE void _upb_sethas_field(const upb_Message* msg,
-                                  const upb_MiniTableField* f) {
-  _upb_sethas(msg, _upb_Message_Hasidx(f));
-}
-
-// Oneof case access ///////////////////////////////////////////////////////////
-
-UPB_INLINE size_t _upb_oneofcase_ofs(const upb_MiniTableField* f) {
-  UPB_ASSERT(f->presence < 0);
-  return ~(ptrdiff_t)f->presence;
-}
-
-UPB_INLINE uint32_t* _upb_oneofcase_field(upb_Message* msg,
-                                          const upb_MiniTableField* f) {
-  return UPB_PTR_AT(msg, _upb_oneofcase_ofs(f), uint32_t);
-}
-
-UPB_INLINE uint32_t _upb_getoneofcase_field(const upb_Message* msg,
-                                            const upb_MiniTableField* f) {
-  return *_upb_oneofcase_field((upb_Message*)msg, f);
-}
-
-// LINT.ThenChange(GoogleInternalName2)
-// LINT.ThenChange(//depot/google3/third_party/upb/js/impl/upb_bits/presence.ts:presence_logic)
-
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 
 #include "upb/port/undef.inc"
 
-#endif /* UPB_MINI_TABLE_FIELD_INTERNAL_H_ */
+#endif /* UPB_MINI_TABLE_INTERNAL_FIELD_H_ */

data/third_party/upb/upb/mini_table/{file_internal.h → internal/file.h}

@@ -25,10 +25,12 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef UPB_MINI_TABLE_FILE_INTERNAL_H_
-#define UPB_MINI_TABLE_FILE_INTERNAL_H_
+#ifndef UPB_MINI_TABLE_INTERNAL_FILE_H_
+#define UPB_MINI_TABLE_INTERNAL_FILE_H_
 
-#include "upb/mini_table/types.h"
+#include "upb/mini_table/internal/enum.h"
+#include "upb/mini_table/internal/extension.h"
+#include "upb/mini_table/internal/message.h"
 
 // Must be last.
 #include "upb/port/def.inc"
@@ -44,4 +46,4 @@ struct upb_MiniTableFile {
 
 #include "upb/port/undef.inc"
 
-#endif /* UPB_MINI_TABLE_FILE_INTERNAL_H_ */
+#endif /* UPB_MINI_TABLE_INTERNAL_FILE_H_ */

data/third_party/upb/upb/mini_table/internal/message.c

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023, Google LLC
+ * All rights reserved.
+ *
+ * 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 LLC 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 Google LLC 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 "upb/mini_table/internal/message.h"
+
+const struct upb_MiniTable _kUpb_MiniTable_Empty = {
+    .subs = NULL,
+    .fields = NULL,
+    .size = 0,
+    .field_count = 0,
+    .ext = kUpb_ExtMode_NonExtendable,
+    .dense_below = 0,
+    .table_mask = -1,
+    .required_count = 0,
+};

data/third_party/upb/upb/mini_table/{message_internal.h → internal/message.h}

@@ -25,16 +25,16 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef UPB_MINI_TABLE_MESSAGE_INTERNAL_H_
-#define UPB_MINI_TABLE_MESSAGE_INTERNAL_H_
+#ifndef UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
+#define UPB_MINI_TABLE_INTERNAL_MESSAGE_H_
 
-#include "upb/base/string_view.h"
-#include "upb/hash/common.h"
-#include "upb/mini_table/types.h"
+#include "upb/mini_table/internal/field.h"
 
 // Must be last.
 #include "upb/port/def.inc"
 
+typedef void upb_Message;
+
 struct upb_Decoder;
 typedef const char* _upb_FieldParser(struct upb_Decoder* d, const char* ptr,
                                      upb_Message* msg, intptr_t table,
@@ -58,12 +58,14 @@ typedef enum {
 
 // LINT.IfChange(mini_table_layout)
 
+union upb_MiniTableSub;
+
 // upb_MiniTable represents the memory layout of a given upb_MessageDef.
 // The members are public so generated code can initialize them,
 // but users MUST NOT directly read or write any of its members.
 struct upb_MiniTable {
-  const upb_MiniTableSub* subs;
-  const upb_MiniTableField* fields;
+  const union upb_MiniTableSub* subs;
+  const struct upb_MiniTableField* fields;
 
   // Must be aligned to sizeof(void*). Doesn't include internal members like
   // unknown fields, extension dict, pointer to msglayout, etc.
@@ -83,45 +85,20 @@ struct upb_MiniTable {
 
 // LINT.ThenChange(//depot/google3/third_party/upb/js/impl/upb_bits/mini_table.ts:presence_logic)
 
-// Map entries aren't actually stored for map fields, they are only used during
-// parsing. For parsing, it helps a lot if all map entry messages have the same
-// layout. The layout code in mini_table/decode.c will ensure that all map
-// entries have this layout.
-//
-// Note that users can and do create map entries directly, which will also use
-// this layout.
-//
-// NOTE: sync with mini_table/decode.c.
-typedef struct {
-  // We only need 2 hasbits max, but due to alignment we'll use 8 bytes here,
-  // and the uint64_t helps make this clear.
-  uint64_t hasbits;
-  union {
-    upb_StringView str;  // For str/bytes.
-    upb_value val;       // For all other types.
-  } k;
-  union {
-    upb_StringView str;  // For str/bytes.
-    upb_value val;       // For all other types.
-  } v;
-} upb_MapEntryData;
-
-typedef struct {
-  void* internal_data;
-  upb_MapEntryData data;
-} upb_MapEntry;
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+// A MiniTable for an empty message, used for unlinked sub-messages.
+extern const struct upb_MiniTable _kUpb_MiniTable_Empty;
+
 // Computes a bitmask in which the |l->required_count| lowest bits are set,
 // except that we skip the lowest bit (because upb never uses hasbit 0).
 //
 // Sample output:
 //    requiredmask(1) => 0b10 (0x2)
 //    requiredmask(5) => 0b111110 (0x3e)
-UPB_INLINE uint64_t upb_MiniTable_requiredmask(const upb_MiniTable* l) {
+UPB_INLINE uint64_t upb_MiniTable_requiredmask(const struct upb_MiniTable* l) {
   int n = l->required_count;
   assert(0 < n && n <= 63);
   return ((1ULL << n) - 1) << 1;
@@ -133,4 +110,4 @@ UPB_INLINE uint64_t upb_MiniTable_requiredmask(const upb_MiniTable* l) {
 
 #include "upb/port/undef.inc"
 
-#endif /* UPB_MINI_TABLE_MESSAGE_INTERNAL_H_ */
+#endif /* UPB_MINI_TABLE_INTERNAL_MESSAGE_H_ */

data/third_party/upb/upb/mini_table/{sub_internal.h → internal/sub.h}

@@ -25,14 +25,15 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef UPB_MINI_TABLE_SUB_INTERNAL_H_
-#define UPB_MINI_TABLE_SUB_INTERNAL_H_
+#ifndef UPB_MINI_TABLE_INTERNAL_SUB_H_
+#define UPB_MINI_TABLE_INTERNAL_SUB_H_
 
-#include "upb/mini_table/types.h"
+#include "upb/mini_table/internal/enum.h"
+#include "upb/mini_table/internal/message.h"
 
 union upb_MiniTableSub {
-  const upb_MiniTable* submsg;
-  const upb_MiniTableEnum* subenum;
+  const struct upb_MiniTable* submsg;
+  const struct upb_MiniTableEnum* subenum;
 };
 
-#endif /* UPB_MINI_TABLE_SUB_INTERNAL_H_ */
+#endif /* UPB_MINI_TABLE_INTERNAL_SUB_H_ */

data/third_party/upb/upb/mini_table/{common.c → message.c}

@@ -25,34 +25,16 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "upb/mini_table/common.h"
+#include "upb/mini_table/message.h"
 
 #include <inttypes.h>
 
 #include "upb/mem/arena.h"
-#include "upb/mini_table/common_internal.h"
+#include "upb/mini_table/internal/message.h"
 
 // Must be last.
 #include "upb/port/def.inc"
 
-const char _kUpb_ToBase92[] = {
-    ' ', '!', '#', '$', '%', '&', '(', ')', '*', '+', ',', '-', '.', '/',
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=',
-    '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
-    'Z', '[', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
-    'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '{', '|', '}', '~',
-};
-
-const int8_t _kUpb_FromBase92[] = {
-    0,  1,  -1, 2,  3,  4,  5,  -1, 6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
-    17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
-    36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
-    55, 56, 57, -1, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
-    73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
-};
-
 const upb_MiniTableField* upb_MiniTable_FindFieldByNumber(
     const upb_MiniTable* t, uint32_t number) {
   const size_t i = ((size_t)number) - 1;  // 0 wraps to SIZE_MAX
@@ -82,19 +64,6 @@ const upb_MiniTableField* upb_MiniTable_FindFieldByNumber(
   return NULL;
 }
 
-upb_FieldType upb_MiniTableField_Type(const upb_MiniTableField* field) {
-  if (field->mode & kUpb_LabelFlags_IsAlternate) {
-    if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Int32) {
-      return kUpb_FieldType_Enum;
-    } else if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bytes) {
-      return kUpb_FieldType_String;
-    } else {
-      UPB_ASSERT(false);
-    }
-  }
-  return field->UPB_PRIVATE(descriptortype);
-}
-
 static bool upb_MiniTable_Is_Oneof(const upb_MiniTableField* f) {
   return f->presence < 0;
 }

data/third_party/upb/upb/mini_table/{common.h → message.h}

@@ -25,34 +25,22 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef UPB_MINI_TABLE_COMMON_H_
-#define UPB_MINI_TABLE_COMMON_H_
+#ifndef UPB_MINI_TABLE_MESSAGE_H_
+#define UPB_MINI_TABLE_MESSAGE_H_
 
-#include "upb/mini_table/field_internal.h"
-#include "upb/mini_table/message_internal.h"
-#include "upb/mini_table/sub_internal.h"
+#include "upb/mini_table/enum.h"
+#include "upb/mini_table/field.h"
+#include "upb/mini_table/internal/message.h"
 
 // Must be last.
 #include "upb/port/def.inc"
 
-typedef enum {
-  kUpb_FieldModifier_IsRepeated = 1 << 0,
-  kUpb_FieldModifier_IsPacked = 1 << 1,
-  kUpb_FieldModifier_IsClosedEnum = 1 << 2,
-  kUpb_FieldModifier_IsProto3Singular = 1 << 3,
-  kUpb_FieldModifier_IsRequired = 1 << 4,
-} kUpb_FieldModifier;
-
-typedef enum {
-  kUpb_MessageModifier_ValidateUtf8 = 1 << 0,
-  kUpb_MessageModifier_DefaultIsPacked = 1 << 1,
-  kUpb_MessageModifier_IsExtendable = 1 << 2,
-} kUpb_MessageModifier;
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef struct upb_MiniTable upb_MiniTable;
+
 UPB_API const upb_MiniTableField* upb_MiniTable_FindFieldByNumber(
     const upb_MiniTable* table, uint32_t number);
 
@@ -61,68 +49,15 @@ UPB_API_INLINE const upb_MiniTableField* upb_MiniTable_GetFieldByIndex(
   return &t->fields[index];
 }
 
-UPB_API upb_FieldType upb_MiniTableField_Type(const upb_MiniTableField* field);
-
-UPB_API_INLINE upb_CType upb_MiniTableField_CType(const upb_MiniTableField* f) {
-  switch (f->UPB_PRIVATE(descriptortype)) {
-    case kUpb_FieldType_Double:
-      return kUpb_CType_Double;
-    case kUpb_FieldType_Float:
-      return kUpb_CType_Float;
-    case kUpb_FieldType_Int64:
-    case kUpb_FieldType_SInt64:
-    case kUpb_FieldType_SFixed64:
-      return kUpb_CType_Int64;
-    case kUpb_FieldType_Int32:
-    case kUpb_FieldType_SFixed32:
-    case kUpb_FieldType_SInt32:
-      return kUpb_CType_Int32;
-    case kUpb_FieldType_UInt64:
-    case kUpb_FieldType_Fixed64:
-      return kUpb_CType_UInt64;
-    case kUpb_FieldType_UInt32:
-    case kUpb_FieldType_Fixed32:
-      return kUpb_CType_UInt32;
-    case kUpb_FieldType_Enum:
-      return kUpb_CType_Enum;
-    case kUpb_FieldType_Bool:
-      return kUpb_CType_Bool;
-    case kUpb_FieldType_String:
-      return kUpb_CType_String;
-    case kUpb_FieldType_Bytes:
-      return kUpb_CType_Bytes;
-    case kUpb_FieldType_Group:
-    case kUpb_FieldType_Message:
-      return kUpb_CType_Message;
-  }
-  UPB_UNREACHABLE();
-}
-
-UPB_API_INLINE bool upb_MiniTableField_IsExtension(
-    const upb_MiniTableField* field) {
-  return field->mode & kUpb_LabelFlags_IsExtension;
-}
-
-UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum(
-    const upb_MiniTableField* field) {
-  return field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Enum;
-}
-
-UPB_API_INLINE bool upb_MiniTableField_HasPresence(
-    const upb_MiniTableField* field) {
-  if (upb_MiniTableField_IsExtension(field)) {
-    return !upb_IsRepeatedOrMap(field);
-  } else {
-    return field->presence != 0;
-  }
-}
-
 // Returns the MiniTable for this message field.  If the field is unlinked,
 // returns NULL.
 UPB_API_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
     const upb_MiniTable* mini_table, const upb_MiniTableField* field) {
   UPB_ASSERT(upb_MiniTableField_CType(field) == kUpb_CType_Message);
-  return mini_table->subs[field->UPB_PRIVATE(submsg_index)].submsg;
+  const upb_MiniTable* ret =
+      mini_table->subs[field->UPB_PRIVATE(submsg_index)].submsg;
+  UPB_ASSUME(ret);
+  return ret == &_kUpb_MiniTable_Empty ? NULL : ret;
 }
 
 // Returns the MiniTableEnum for this enum field.  If the field is unlinked,
@@ -167,4 +102,4 @@ bool upb_MiniTable_NextOneofField(const upb_MiniTable* m,
 
 #include "upb/port/undef.inc"
 
-#endif /* UPB_MINI_TABLE_COMMON_H_ */
+#endif /* UPB_MINI_TABLE_MESSAGE_H_ */

data/third_party/upb/upb/{json_encode.h → mini_table/sub.h}

@@ -25,12 +25,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// This header is deprecated, use upb/json/encode.h instead
-// IWYU pragma: private, include "upb/json/encode.h"
+#ifndef UPB_MINI_TABLE_SUB_H_
+#define UPB_MINI_TABLE_SUB_H_
 
-#ifndef UPB_JSONENCODE_H_
-#define UPB_JSONENCODE_H_
+#include "upb/mini_table/internal/sub.h"
 
-#include "upb/json/encode.h"
+typedef union upb_MiniTableSub upb_MiniTableSub;
 
-#endif /* UPB_JSONENCODE_H_ */
+#endif /* UPB_MINI_TABLE_INTERNAL_SUB_H_ */

data/third_party/upb/upb/reflection/def.hpp

@@ -318,8 +318,14 @@ class MessageDefPtr {
     FieldDefPtr operator*() {
       return FieldDefPtr(upb_MessageDef_Field(m_, i_));
     }
-    bool operator!=(const FieldIter& other) { return i_ != other.i_; }
-    bool operator==(const FieldIter& other) { return i_ == other.i_; }
+
+    friend bool operator==(FieldIter lhs, FieldIter rhs) {
+      return lhs.i_ == rhs.i_;
+    }
+
+    friend bool operator!=(FieldIter lhs, FieldIter rhs) {
+      return !(lhs == rhs);
+    }
 
    private:
     const upb_MessageDef* m_;
@@ -344,8 +350,14 @@ class MessageDefPtr {
     OneofDefPtr operator*() {
       return OneofDefPtr(upb_MessageDef_Oneof(m_, i_));
     }
-    bool operator!=(const OneofIter& other) { return i_ != other.i_; }
-    bool operator==(const OneofIter& other) { return i_ == other.i_; }
+
+    friend bool operator==(OneofIter lhs, OneofIter rhs) {
+      return lhs.i_ == rhs.i_;
+    }
+
+    friend bool operator!=(OneofIter lhs, OneofIter rhs) {
+      return !(lhs == rhs);
+    }
 
    private:
     const upb_MessageDef* m_;

data/third_party/upb/upb/reflection/def_pool_internal.h

@@ -28,7 +28,7 @@
 #ifndef UPB_REFLECTION_DEF_POOL_INTERNAL_H_
 #define UPB_REFLECTION_DEF_POOL_INTERNAL_H_
 
-#include "upb/mini_table/decode.h"
+#include "upb/mini_descriptor/decode.h"
 #include "upb/reflection/def_pool.h"
 
 // Must be last.

data/third_party/upb/upb/reflection/desc_state_internal.h

@@ -29,7 +29,7 @@
 #define UPB_REFLECTION_DESC_STATE_INTERNAL_H_
 
 #include "upb/mem/arena.h"
-#include "upb/mini_table/encode_internal.h"
+#include "upb/mini_descriptor/internal/encode.h"
 
 // Must be last.
 #include "upb/port/def.inc"

data/third_party/upb/upb/reflection/enum_def.c

@@ -27,7 +27,7 @@
 
 #include "upb/hash/int_table.h"
 #include "upb/hash/str_table.h"
-#include "upb/mini_table/decode.h"
+#include "upb/mini_descriptor/decode.h"
 #include "upb/reflection/def_builder_internal.h"
 #include "upb/reflection/def_type.h"
 #include "upb/reflection/desc_state_internal.h"

data/third_party/upb/upb/reflection/field_def.c

@@ -28,7 +28,8 @@
 #include <ctype.h>
 #include <errno.h>
 
-#include "upb/mini_table/decode.h"
+#include "upb/mini_descriptor/decode.h"
+#include "upb/mini_descriptor/internal/modifiers.h"
 #include "upb/reflection/def.h"
 #include "upb/reflection/def_builder_internal.h"
 #include "upb/reflection/def_pool.h"

data/third_party/upb/upb/reflection/message.c

@@ -33,7 +33,7 @@
 #include "upb/hash/common.h"
 #include "upb/message/accessors.h"
 #include "upb/message/message.h"
-#include "upb/mini_table/field_internal.h"
+#include "upb/mini_table/field.h"
 #include "upb/reflection/def.h"
 #include "upb/reflection/def_pool.h"
 #include "upb/reflection/def_type.h"
@@ -121,7 +121,7 @@ void upb_Message_ClearFieldByDef(upb_Message* msg, const upb_FieldDef* f) {
 }
 
 void upb_Message_ClearByDef(upb_Message* msg, const upb_MessageDef* m) {
-  _upb_Message_Clear(msg, upb_MessageDef_MiniTable(m));
+  upb_Message_Clear(msg, upb_MessageDef_MiniTable(m));
 }
 
 bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,

data/third_party/upb/upb/reflection/message_def.c

@@ -27,7 +27,8 @@
 
 #include "upb/hash/int_table.h"
 #include "upb/hash/str_table.h"
-#include "upb/mini_table/decode.h"
+#include "upb/mini_descriptor/decode.h"
+#include "upb/mini_descriptor/internal/modifiers.h"
 #include "upb/reflection/def.h"
 #include "upb/reflection/def_builder_internal.h"
 #include "upb/reflection/def_type.h"
@@ -499,6 +500,7 @@ void _upb_MessageDef_LinkMiniTable(upb_DefBuilder* ctx,
     UPB_ASSERT(layout_index < m->layout->field_count);
     const upb_MiniTableField* mt_f = &m->layout->fields[layout_index];
     UPB_ASSERT(upb_FieldDef_Type(f) == upb_MiniTableField_Type(mt_f));
+    UPB_ASSERT(upb_FieldDef_CType(f) == upb_MiniTableField_CType(mt_f));
     UPB_ASSERT(upb_FieldDef_HasPresence(f) ==
                upb_MiniTableField_HasPresence(mt_f));
   }