diff --git a/ruby/ext/google/protobuf_c/ruby-upb.c b/ruby/ext/google/protobuf_c/ruby-upb.c
index dab723b..5a479fa 100644
--- a/ruby/ext/google/protobuf_c/ruby-upb.c
+++ b/ruby/ext/google/protobuf_c/ruby-upb.c
@@ -6229,6 +6229,9 @@
 }
 
 
+#include <stddef.h>
+#include <stdint.h>
+
 
 // Must be last.
 
@@ -6254,26 +6257,27 @@
     d->enum_table = upb_Arena_Realloc(d->arena, d->enum_table, old_sz, new_sz);
     upb_MdDecoder_CheckOutOfMemory(&d->base, d->enum_table);
   }
-  d->enum_table->data[d->enum_data_count++] = val;
+  d->enum_table->UPB_PRIVATE(data)[d->enum_data_count++] = val;
   return d->enum_table;
 }
 
 static void upb_MiniTableEnum_BuildValue(upb_MdEnumDecoder* d, uint32_t val) {
   upb_MiniTableEnum* table = d->enum_table;
   d->enum_value_count++;
-  if (table->value_count || (val > 512 && d->enum_value_count < val / 32)) {
-    if (table->value_count == 0) {
-      assert(d->enum_data_count == table->mask_limit / 32);
+  if (table->UPB_PRIVATE(value_count) ||
+      (val > 512 && d->enum_value_count < val / 32)) {
+    if (table->UPB_PRIVATE(value_count) == 0) {
+      UPB_ASSERT(d->enum_data_count == table->UPB_PRIVATE(mask_limit) / 32);
     }
     table = _upb_MiniTable_AddEnumDataMember(d, val);
-    table->value_count++;
+    table->UPB_PRIVATE(value_count)++;
   } else {
     uint32_t new_mask_limit = ((val / 32) + 1) * 32;
-    while (table->mask_limit < new_mask_limit) {
+    while (table->UPB_PRIVATE(mask_limit) < new_mask_limit) {
       table = _upb_MiniTable_AddEnumDataMember(d, 0);
-      table->mask_limit += 32;
+      table->UPB_PRIVATE(mask_limit) += 32;
     }
-    table->data[val / 32] |= 1ULL << (val % 32);
+    table->UPB_PRIVATE(data)[val / 32] |= 1ULL << (val % 32);
   }
 }
 
@@ -6291,11 +6295,11 @@
   upb_MdDecoder_CheckOutOfMemory(&d->base, d->enum_table);
 
   // Guarantee at least 64 bits of mask without checking mask size.
-  d->enum_table->mask_limit = 64;
+  d->enum_table->UPB_PRIVATE(mask_limit) = 64;
   d->enum_table = _upb_MiniTable_AddEnumDataMember(d, 0);
   d->enum_table = _upb_MiniTable_AddEnumDataMember(d, 0);
 
-  d->enum_table->value_count = 0;
+  d->enum_table->UPB_PRIVATE(value_count) = 0;
 
   const char* ptr = data;
   uint32_t base = 0;
@@ -6323,7 +6327,8 @@
 }
 
 static upb_MiniTableEnum* upb_MtDecoder_BuildMiniTableEnum(
-    upb_MdEnumDecoder* const decoder, const char* const data, size_t const len) {
+    upb_MdEnumDecoder* const decoder, const char* const data,
+    size_t const len) {
   if (UPB_SETJMP(decoder->base.err) != 0) return NULL;
   return upb_MtDecoder_DoBuildMiniTableEnum(decoder, data, len);
 }
diff --git a/ruby/ext/google/protobuf_c/ruby-upb.h b/ruby/ext/google/protobuf_c/ruby-upb.h
index d2a531c..a3ff8a8 100755
--- a/ruby/ext/google/protobuf_c/ruby-upb.h
+++ b/ruby/ext/google/protobuf_c/ruby-upb.h
@@ -935,9 +935,9 @@
 // Must be last.
 
 struct upb_MiniTableEnum {
-  uint32_t mask_limit;   // Limit enum value that can be tested with mask.
-  uint32_t value_count;  // Number of values after the bitfield.
-  uint32_t data[];       // Bitmask + enumerated values follow.
+  uint32_t UPB_PRIVATE(mask_limit);   // Highest that can be tested with mask.
+  uint32_t UPB_PRIVATE(value_count);  // Number of values after the bitfield.
+  uint32_t UPB_PRIVATE(data)[];       // Bitmask + enumerated values follow.
 };
 
 #ifdef __cplusplus
@@ -947,19 +947,22 @@
 UPB_INLINE bool UPB_PRIVATE(_upb_MiniTableEnum_CheckValue)(
     const struct upb_MiniTableEnum* e, uint32_t val) {
   if (UPB_LIKELY(val < 64)) {
-    const uint64_t mask = e->data[0] | ((uint64_t)e->data[1] << 32);
+    const uint64_t mask =
+        e->UPB_PRIVATE(data)[0] | ((uint64_t)e->UPB_PRIVATE(data)[1] << 32);
     const uint64_t bit = 1ULL << val;
     return (mask & bit) != 0;
   }
-  if (UPB_LIKELY(val < e->mask_limit)) {
-    const uint32_t mask = e->data[val / 32];
+  if (UPB_LIKELY(val < e->UPB_PRIVATE(mask_limit))) {
+    const uint32_t mask = e->UPB_PRIVATE(data)[val / 32];
     const uint32_t bit = 1ULL << (val % 32);
     return (mask & bit) != 0;
   }
 
   // OPT: binary search long lists?
-  const uint32_t* start = &e->data[e->mask_limit / 32];
-  const uint32_t* limit = &e->data[e->mask_limit / 32 + e->value_count];
+  const uint32_t* start =
+      &e->UPB_PRIVATE(data)[e->UPB_PRIVATE(mask_limit) / 32];
+  const uint32_t* limit = &e->UPB_PRIVATE(
+      data)[e->UPB_PRIVATE(mask_limit) / 32 + e->UPB_PRIVATE(value_count)];
   for (const uint32_t* p = start; p < limit; p++) {
     if (*p == val) return true;
   }
@@ -11942,10 +11945,6 @@
 
 #endif /* UPB_COLLECTIONS_INTERNAL_MAP_SORTER_H_ */
 
-#ifndef UPB_MINI_DESCRIPTOR_INTERNAL_DECODER_H_
-#define UPB_MINI_DESCRIPTOR_INTERNAL_DECODER_H_
-
-
 #ifndef UPB_MINI_DESCRIPTOR_INTERNAL_BASE92_H_
 #define UPB_MINI_DESCRIPTOR_INTERNAL_BASE92_H_
 
@@ -12000,6 +11999,10 @@
 
 #endif  // UPB_MINI_DESCRIPTOR_INTERNAL_BASE92_H_
 
+#ifndef UPB_MINI_DESCRIPTOR_INTERNAL_DECODER_H_
+#define UPB_MINI_DESCRIPTOR_INTERNAL_DECODER_H_
+
+
 // Must be last.
 
 // upb_MdDecoder: used internally for decoding MiniDescriptors for messages,