Hide `upb_MiniTableField.descriptortype` with `UPB_PRIVATE()` macro
PiperOrigin-RevId: 524371449
diff --git a/upb/message/accessors.c b/upb/message/accessors.c
index dc3ea01..2f1dd7c 100644
--- a/upb/message/accessors.c
+++ b/upb/message/accessors.c
@@ -76,7 +76,7 @@
upb_Message* msg, const upb_MiniTableExtension* ext_table,
int decode_options, upb_Arena* arena,
const upb_Message_Extension** extension) {
- UPB_ASSERT(ext_table->field.descriptortype == kUpb_FieldType_Message);
+ UPB_ASSERT(upb_MiniTableField_CType(&ext_table->field) == kUpb_CType_Message);
*extension = _upb_Message_Getext(msg, ext_table);
if (*extension) {
return kUpb_GetExtension_Ok;
@@ -125,7 +125,7 @@
int encode_options, upb_Arena* arena, const char** extension_data,
size_t* len) {
const upb_Message_Extension* msg_ext = _upb_Message_Getext(msg, ext_table);
- UPB_ASSERT(ext_table->field.descriptortype == kUpb_FieldType_Message);
+ UPB_ASSERT(upb_MiniTableField_CType(&ext_table->field) == kUpb_CType_Message);
if (msg_ext) {
upb_EncodeStatus status =
upb_Encode(msg_ext->data.ptr, msg_ext->ext->sub.submsg, encode_options,
diff --git a/upb/message/accessors.h b/upb/message/accessors.h
index 141a97d..69e3aac 100644
--- a/upb/message/accessors.h
+++ b/upb/message/accessors.h
@@ -152,7 +152,7 @@
2, // kUpb_FieldType_SInt32 = 17,
3, // kUpb_FieldType_SInt64 = 18,
};
- return table[field->descriptortype];
+ return table[field->UPB_PRIVATE(descriptortype)];
}
// Here we define universal getter/setter functions for message fields.
@@ -172,7 +172,7 @@
// UPB_INLINE bool upb_Message_SetBool(upb_Message* msg,
// const upb_MiniTableField* field,
// bool value, upb_Arena* a) {
-// UPB_ASSUME(field->descriptortype == kUpb_FieldType_Bool);
+// UPB_ASSUME(field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bool);
// UPB_ASSUME(!upb_IsRepeatedOrMap(field));
// UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_1Byte);
// _upb_Message_SetField(msg, field, &value, a);
@@ -347,9 +347,9 @@
UPB_API_INLINE bool upb_Message_GetBool(const upb_Message* msg,
const upb_MiniTableField* field,
bool default_val) {
- UPB_ASSUME(field->descriptortype == kUpb_FieldType_Bool);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_1Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
bool ret;
_upb_Message_GetField(msg, field, &default_val, &ret);
return ret;
@@ -358,21 +358,19 @@
UPB_API_INLINE bool upb_Message_SetBool(upb_Message* msg,
const upb_MiniTableField* field,
bool value, upb_Arena* a) {
- UPB_ASSUME(field->descriptortype == kUpb_FieldType_Bool);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Bool);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_1Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE int32_t upb_Message_GetInt32(const upb_Message* msg,
const upb_MiniTableField* field,
int32_t default_val) {
- UPB_ASSUME(field->descriptortype == kUpb_FieldType_Int32 ||
- field->descriptortype == kUpb_FieldType_SInt32 ||
- field->descriptortype == kUpb_FieldType_SFixed32 ||
- field->descriptortype == kUpb_FieldType_Enum);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32 ||
+ upb_MiniTableField_CType(field) == kUpb_CType_Enum);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
int32_t ret;
_upb_Message_GetField(msg, field, &default_val, &ret);
return ret;
@@ -381,21 +379,18 @@
UPB_API_INLINE bool upb_Message_SetInt32(upb_Message* msg,
const upb_MiniTableField* field,
int32_t value, upb_Arena* a) {
- UPB_ASSUME(field->descriptortype == kUpb_FieldType_Int32 ||
- field->descriptortype == kUpb_FieldType_SInt32 ||
- field->descriptortype == kUpb_FieldType_SFixed32);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int32);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE uint32_t upb_Message_GetUInt32(const upb_Message* msg,
const upb_MiniTableField* field,
uint32_t default_val) {
- UPB_ASSUME(field->descriptortype == kUpb_FieldType_UInt32 ||
- field->descriptortype == kUpb_FieldType_Fixed32);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
uint32_t ret;
_upb_Message_GetField(msg, field, &default_val, &ret);
return ret;
@@ -404,19 +399,18 @@
UPB_API_INLINE bool upb_Message_SetUInt32(upb_Message* msg,
const upb_MiniTableField* field,
uint32_t value, upb_Arena* a) {
- UPB_ASSUME(field->descriptortype == kUpb_FieldType_UInt32 ||
- field->descriptortype == kUpb_FieldType_Fixed32);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt32);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE void upb_Message_SetEnumProto2(
upb_Message* msg, const upb_MiniTable* msg_mini_table,
const upb_MiniTableField* field, int32_t value) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSERT(upb_MiniTableField_IsClosedEnum(field));
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
UPB_ASSERT(upb_MiniTableEnum_CheckValue(
upb_MiniTable_GetSubEnumTable(msg_mini_table, field), value));
_upb_Message_SetNonExtensionField(msg, field, &value);
@@ -425,11 +419,9 @@
UPB_API_INLINE int64_t upb_Message_GetInt64(const upb_Message* msg,
const upb_MiniTableField* field,
uint64_t default_val) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 ||
- field->descriptortype == kUpb_FieldType_SInt64 ||
- field->descriptortype == kUpb_FieldType_SFixed64);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
int64_t ret;
_upb_Message_GetField(msg, field, &default_val, &ret);
return ret;
@@ -438,21 +430,18 @@
UPB_API_INLINE bool upb_Message_SetInt64(upb_Message* msg,
const upb_MiniTableField* field,
int64_t value, upb_Arena* a) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 ||
- field->descriptortype == kUpb_FieldType_SInt64 ||
- field->descriptortype == kUpb_FieldType_SFixed64);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Int64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE uint64_t upb_Message_GetUInt64(const upb_Message* msg,
const upb_MiniTableField* field,
uint64_t default_val) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 ||
- field->descriptortype == kUpb_FieldType_Fixed64);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
uint64_t ret;
_upb_Message_GetField(msg, field, &default_val, &ret);
return ret;
@@ -461,19 +450,18 @@
UPB_API_INLINE bool upb_Message_SetUInt64(upb_Message* msg,
const upb_MiniTableField* field,
uint64_t value, upb_Arena* a) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 ||
- field->descriptortype == kUpb_FieldType_Fixed64);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_UInt64);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE float upb_Message_GetFloat(const upb_Message* msg,
const upb_MiniTableField* field,
float default_val) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
float ret;
_upb_Message_GetField(msg, field, &default_val, &ret);
return ret;
@@ -482,18 +470,18 @@
UPB_API_INLINE bool upb_Message_SetFloat(upb_Message* msg,
const upb_MiniTableField* field,
float value, upb_Arena* a) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Float);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_4Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE double upb_Message_GetDouble(const upb_Message* msg,
const upb_MiniTableField* field,
double default_val) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
double ret;
_upb_Message_GetField(msg, field, &default_val, &ret);
return ret;
@@ -502,19 +490,19 @@
UPB_API_INLINE bool upb_Message_SetDouble(upb_Message* msg,
const upb_MiniTableField* field,
double value, upb_Arena* a) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Double);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_8Byte);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE upb_StringView
upb_Message_GetString(const upb_Message* msg, const upb_MiniTableField* field,
upb_StringView def_val) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes ||
- field->descriptortype == kUpb_FieldType_String);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
+ upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_StringView);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
upb_StringView ret;
_upb_Message_GetField(msg, field, &def_val, &ret);
return ret;
@@ -523,21 +511,20 @@
UPB_API_INLINE bool upb_Message_SetString(upb_Message* msg,
const upb_MiniTableField* field,
upb_StringView value, upb_Arena* a) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes ||
- field->descriptortype == kUpb_FieldType_String);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_String ||
+ upb_MiniTableField_CType(field) == kUpb_CType_Bytes);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) == kUpb_FieldRep_StringView);
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
return _upb_Message_SetField(msg, field, &value, a);
}
UPB_API_INLINE const upb_Message* upb_Message_GetMessage(
const upb_Message* msg, const upb_MiniTableField* field,
upb_Message* default_val) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) ==
UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
upb_Message* ret;
_upb_Message_GetNonExtensionField(msg, field, &default_val, &ret);
return ret;
@@ -547,11 +534,10 @@
const upb_MiniTable* mini_table,
const upb_MiniTableField* field,
upb_Message* sub_message) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group);
- UPB_ASSUME(!upb_IsRepeatedOrMap(field));
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
UPB_ASSUME(_upb_MiniTableField_GetRep(field) ==
UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte));
+ UPB_ASSUME(!upb_IsRepeatedOrMap(field));
UPB_ASSERT(mini_table->subs[field->UPB_PRIVATE(submsg_index)].submsg);
_upb_Message_SetNonExtensionField(msg, field, &sub_message);
}
@@ -559,8 +545,7 @@
UPB_API_INLINE upb_Message* upb_Message_GetOrCreateMutableMessage(
upb_Message* msg, const upb_MiniTable* mini_table,
const upb_MiniTableField* field, upb_Arena* arena) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group);
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
upb_Message* sub_message = *UPB_PTR_AT(msg, field->offset, upb_Message*);
if (!sub_message) {
const upb_MiniTable* sub_mini_table =
@@ -622,11 +607,6 @@
return _upb_array_ptr(arr);
}
-UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum(
- const upb_MiniTableField* field) {
- return field->descriptortype == kUpb_FieldType_Enum;
-}
-
UPB_API_INLINE const upb_Map* upb_Message_GetMap(
const upb_Message* msg, const upb_MiniTableField* field) {
_upb_MiniTableField_CheckIsMap(field);
@@ -639,8 +619,7 @@
UPB_API_INLINE upb_Map* upb_Message_GetOrCreateMutableMap(
upb_Message* msg, const upb_MiniTable* map_entry_mini_table,
const upb_MiniTableField* field, upb_Arena* arena) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group);
+ UPB_ASSUME(upb_MiniTableField_CType(field) == kUpb_CType_Message);
const upb_MiniTableField* map_entry_key_field =
&map_entry_mini_table->fields[0];
const upb_MiniTableField* map_entry_value_field =
diff --git a/upb/message/copy.c b/upb/message/copy.c
index 7fc0795..1d15d08 100644
--- a/upb/message/copy.c
+++ b/upb/message/copy.c
@@ -200,9 +200,8 @@
for (size_t i = 0; i < mini_table->field_count; ++i) {
const upb_MiniTableField* field = &mini_table->fields[i];
if (!upb_IsRepeatedOrMap(field)) {
- switch (field->descriptortype) {
- case kUpb_FieldType_Group:
- case kUpb_FieldType_Message: {
+ switch (upb_MiniTableField_CType(field)) {
+ case kUpb_CType_Message: {
const upb_Message* sub_message =
upb_Message_GetMessage(message, field, NULL);
if (sub_message != NULL) {
@@ -217,8 +216,8 @@
cloned_sub_message);
}
} break;
- case kUpb_FieldType_String:
- case kUpb_FieldType_Bytes: {
+ case kUpb_CType_String:
+ case kUpb_CType_Bytes: {
upb_StringView str =
upb_Message_GetString(message, field, empty_string);
if (str.size != 0) {
diff --git a/upb/mini_table/common.c b/upb/mini_table/common.c
index 34c7c91..63520cc 100644
--- a/upb/mini_table/common.c
+++ b/upb/mini_table/common.c
@@ -84,15 +84,15 @@
upb_FieldType upb_MiniTableField_Type(const upb_MiniTableField* field) {
if (field->mode & kUpb_LabelFlags_IsAlternate) {
- if (field->descriptortype == kUpb_FieldType_Int32) {
+ if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Int32) {
return kUpb_FieldType_Enum;
- } else if (field->descriptortype == kUpb_FieldType_Bytes) {
+ } else if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bytes) {
return kUpb_FieldType_String;
} else {
UPB_ASSERT(false);
}
}
- return field->descriptortype;
+ return field->UPB_PRIVATE(descriptortype);
}
static bool upb_MiniTable_Is_Oneof(const upb_MiniTableField* f) {
diff --git a/upb/mini_table/common.h b/upb/mini_table/common.h
index 4fc9473..50a83c3 100644
--- a/upb/mini_table/common.h
+++ b/upb/mini_table/common.h
@@ -64,7 +64,7 @@
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->descriptortype) {
+ switch (f->UPB_PRIVATE(descriptortype)) {
case kUpb_FieldType_Double:
return kUpb_CType_Double;
case kUpb_FieldType_Float:
@@ -103,6 +103,11 @@
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)) {
diff --git a/upb/mini_table/decode.c b/upb/mini_table/decode.c
index 71e1589..93d124f 100644
--- a/upb/mini_table/decode.c
+++ b/upb/mini_table/decode.c
@@ -138,14 +138,14 @@
static bool upb_MiniTable_HasSub(upb_MiniTableField* field,
uint64_t msg_modifiers) {
- switch (field->descriptortype) {
+ switch (field->UPB_PRIVATE(descriptortype)) {
case kUpb_FieldType_Message:
case kUpb_FieldType_Group:
case kUpb_FieldType_Enum:
return true;
case kUpb_FieldType_String:
if (!(msg_modifiers & kUpb_MessageModifier_ValidateUtf8)) {
- field->descriptortype = kUpb_FieldType_Bytes;
+ field->UPB_PRIVATE(descriptortype) = kUpb_FieldType_Bytes;
field->mode |= kUpb_LabelFlags_IsAlternate;
}
return false;
@@ -156,18 +156,18 @@
static bool upb_MtDecoder_FieldIsPackable(upb_MiniTableField* field) {
return (field->mode & kUpb_FieldMode_Array) &&
- upb_FieldType_IsPackable(field->descriptortype);
+ upb_FieldType_IsPackable(field->UPB_PRIVATE(descriptortype));
}
static void upb_MiniTable_SetTypeAndSub(upb_MiniTableField* field,
upb_FieldType type, uint32_t* sub_count,
uint64_t msg_modifiers,
bool is_proto3_enum) {
- field->descriptortype = type;
+ field->UPB_PRIVATE(descriptortype) = type;
if (is_proto3_enum) {
- UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
- field->descriptortype = kUpb_FieldType_Int32;
+ UPB_ASSERT(field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Enum);
+ field->UPB_PRIVATE(descriptortype) = kUpb_FieldType_Int32;
field->mode |= kUpb_LabelFlags_IsAlternate;
}
@@ -691,7 +691,7 @@
if ((1 << upb_MiniTableField_Type(f)) & not_ok_types) {
upb_MtDecoder_ErrorFormat(d, "map %s cannot have type %d", name,
- (int)f->descriptortype);
+ (int)f->UPB_PRIVATE(descriptortype));
}
}
@@ -1028,7 +1028,7 @@
const bool sub_is_map = sub->ext & kUpb_ExtMode_IsMapEntry;
- switch (field->descriptortype) {
+ switch (field->UPB_PRIVATE(descriptortype)) {
case kUpb_FieldType_Message:
if (sub_is_map) {
const bool table_is_map = table->ext & kUpb_ExtMode_IsMapEntry;
diff --git a/upb/mini_table/encode_test.cc b/upb/mini_table/encode_test.cc
index bca9235..8bae6d6 100644
--- a/upb/mini_table/encode_test.cc
+++ b/upb/mini_table/encode_test.cc
@@ -130,7 +130,7 @@
for (size_t i = 0; i < field_numbers.size(); i++) {
const upb_MiniTableField* f = &table->fields[i];
EXPECT_EQ(field_numbers[i], f->number);
- EXPECT_EQ(kUpb_FieldType_Float, f->descriptortype);
+ EXPECT_EQ(kUpb_FieldType_Float, upb_MiniTableField_Type(f));
EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
EXPECT_TRUE(offsets.insert(f->offset).second);
EXPECT_TRUE(f->offset < table->size);
diff --git a/upb/mini_table/field_internal.h b/upb/mini_table/field_internal.h
index 0e36a07..1494ccc 100644
--- a/upb/mini_table/field_internal.h
+++ b/upb/mini_table/field_internal.h
@@ -45,7 +45,7 @@
// Will be set to `kUpb_NoSub` if `descriptortype` != MESSAGE/GROUP/ENUM
uint16_t UPB_PRIVATE(submsg_index);
- uint8_t descriptortype;
+ uint8_t UPB_PRIVATE(descriptortype);
// upb_FieldMode | upb_LabelFlags | (upb_FieldRep << kUpb_FieldRep_Shift)
uint8_t mode;
@@ -123,8 +123,8 @@
}
UPB_INLINE bool upb_IsSubMessage(const upb_MiniTableField* field) {
- return field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group;
+ return field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Message ||
+ field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group;
}
// LINT.IfChange(presence_logic)
diff --git a/upb/test/BUILD b/upb/test/BUILD
index 7e41fae..ea30218 100644
--- a/upb/test/BUILD
+++ b/upb/test/BUILD
@@ -136,6 +136,7 @@
deps = [
"//:upb",
"//:mini_table_internal",
+ "//:port",
],
)
diff --git a/upb/test/fuzz_util.cc b/upb/test/fuzz_util.cc
index 09b1dae..c0a2d9a 100644
--- a/upb/test/fuzz_util.cc
+++ b/upb/test/fuzz_util.cc
@@ -33,6 +33,9 @@
#include "upb/mini_table/extension_registry.h"
#include "upb/upb.hpp"
+// Must be last
+#include "upb/port/def.inc"
+
namespace upb {
namespace fuzz {
@@ -105,15 +108,14 @@
bool Builder::LinkExtension(upb_MiniTableExtension* ext) {
upb_MiniTableField* field = &ext->field;
- if (field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group) {
+ if (upb_MiniTableField_CType(field) == kUpb_CType_Message) {
auto mt = NextMiniTable();
- if (!mt) field->descriptortype = kUpb_FieldType_Int32;
+ if (!mt) field->UPB_PRIVATE(descriptortype) = kUpb_FieldType_Int32;
ext->sub.submsg = mt;
}
- if (field->descriptortype == kUpb_FieldType_Enum) {
+ if (upb_MiniTableField_IsClosedEnum(field)) {
auto et = NextEnumTable();
- if (!et) field->descriptortype = kUpb_FieldType_Int32;
+ if (!et) field->UPB_PRIVATE(descriptortype) = kUpb_FieldType_Int32;
ext->sub.subenum = et;
}
return true;
@@ -154,20 +156,18 @@
upb_MiniTableField* field =
const_cast<upb_MiniTableField*>(&table->fields[i]);
if (link_ == input_->links.size()) link_ = 0;
- if (field->descriptortype == kUpb_FieldType_Message ||
- field->descriptortype == kUpb_FieldType_Group) {
- if (!upb_MiniTable_SetSubMessage(table, field, NextMiniTable())) {
- return false;
- }
+ if (upb_MiniTableField_CType(field) == kUpb_CType_Message &&
+ !upb_MiniTable_SetSubMessage(table, field, NextMiniTable())) {
+ return false;
}
- if (field->descriptortype == kUpb_FieldType_Enum) {
+ if (upb_MiniTableField_IsClosedEnum(field)) {
auto* et = NextEnumTable();
if (et) {
if (!upb_MiniTable_SetSubEnum(table, field, et)) return false;
} else {
// We don't have any sub-enums. Override the field type so that it is
// not needed.
- field->descriptortype = kUpb_FieldType_Int32;
+ field->UPB_PRIVATE(descriptortype) = kUpb_FieldType_Int32;
}
}
}
diff --git a/upb/wire/decode.c b/upb/wire/decode.c
index 4a33689..4a2cb07 100644
--- a/upb/wire/decode.c
+++ b/upb/wire/decode.c
@@ -408,7 +408,7 @@
while (!_upb_Decoder_IsDone(d, &ptr)) {
wireval elem;
ptr = _upb_Decoder_DecodeVarint(d, ptr, &elem.uint64_val);
- _upb_Decoder_Munge(field->descriptortype, &elem);
+ _upb_Decoder_Munge(field->UPB_PRIVATE(descriptortype), &elem);
if (_upb_Decoder_Reserve(d, arr, 1)) {
out = UPB_PTR_AT(_upb_array_ptr(arr), arr->size << lg2, void);
}
@@ -471,7 +471,7 @@
[kUpb_FieldType_SInt64] = 3,
};
- size_t lg2 = kElemSizeLg2[field->descriptortype];
+ size_t lg2 = kElemSizeLg2[field->UPB_PRIVATE(descriptortype)];
upb_Array* ret = _upb_Array_New(&d->arena, 4, lg2);
if (!ret) _upb_Decoder_ErrorJmp(d, kUpb_DecodeStatus_OutOfMemory);
return ret;
@@ -517,7 +517,8 @@
*UPB_PTR_AT(_upb_array_ptr(arr), arr->size * sizeof(void*),
upb_Message*) = submsg;
arr->size++;
- if (UPB_UNLIKELY(field->descriptortype == kUpb_FieldType_Group)) {
+ if (UPB_UNLIKELY(field->UPB_PRIVATE(descriptortype) ==
+ kUpb_FieldType_Group)) {
return _upb_Decoder_DecodeKnownGroup(d, ptr, submsg, subs, field);
} else {
return _upb_Decoder_DecodeSubMessage(d, ptr, submsg, subs, field,
@@ -568,8 +569,8 @@
const upb_MiniTableField* key_field = &entry->fields[0];
const upb_MiniTableField* val_field = &entry->fields[1];
- char key_size = kSizeInMap[key_field->descriptortype];
- char val_size = kSizeInMap[val_field->descriptortype];
+ char key_size = kSizeInMap[key_field->UPB_PRIVATE(descriptortype)];
+ char val_size = kSizeInMap[val_field->UPB_PRIVATE(descriptortype)];
UPB_ASSERT(key_field->offset == offsetof(upb_MapEntryData, k));
UPB_ASSERT(val_field->offset == offsetof(upb_MapEntryData, v));
upb_Map* ret = _upb_Map_New(&d->arena, key_size, val_size);
@@ -600,8 +601,8 @@
// Parse map entry.
memset(&ent, 0, sizeof(ent));
- if (entry->fields[1].descriptortype == kUpb_FieldType_Message ||
- entry->fields[1].descriptortype == kUpb_FieldType_Group) {
+ if (entry->fields[1].UPB_PRIVATE(descriptortype) == kUpb_FieldType_Message ||
+ entry->fields[1].UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group) {
const upb_MiniTable* submsg_table = entry->subs[0].submsg;
// Any sub-message entry must be linked. We do not allow dynamic tree
// shaking in this case.
@@ -644,7 +645,7 @@
const upb_MiniTableSub* subs, const upb_MiniTableField* field, wireval* val,
int op) {
void* mem = UPB_PTR_AT(msg, field->offset, void);
- int type = field->descriptortype;
+ int type = field->UPB_PRIVATE(descriptortype);
if (UPB_UNLIKELY(op == kUpb_DecodeOp_Enum) &&
!_upb_Decoder_CheckEnum(d, ptr, msg,
@@ -955,7 +956,7 @@
[kUpb_FakeFieldType_MessageSetItem] = kUpb_DecodeOp_UnknownField,
};
- return kVarintOps[field->descriptortype];
+ return kVarintOps[field->UPB_PRIVATE(descriptortype)];
}
UPB_FORCEINLINE
@@ -1018,7 +1019,7 @@
// repeated msgset type
};
- int ndx = field->descriptortype;
+ int ndx = field->UPB_PRIVATE(descriptortype);
if (upb_FieldMode_Get(field) == kUpb_FieldMode_Array) ndx += kRepeatedBase;
int op = kDelimitedOps[ndx];
@@ -1047,17 +1048,17 @@
case kUpb_WireType_Varint:
ptr = _upb_Decoder_DecodeVarint(d, ptr, &val->uint64_val);
*op = _upb_Decoder_GetVarintOp(field);
- _upb_Decoder_Munge(field->descriptortype, val);
+ _upb_Decoder_Munge(field->UPB_PRIVATE(descriptortype), val);
return ptr;
case kUpb_WireType_32Bit:
*op = kUpb_DecodeOp_Scalar4Byte;
- if (((1 << field->descriptortype) & kFixed32OkMask) == 0) {
+ if (((1 << field->UPB_PRIVATE(descriptortype)) & kFixed32OkMask) == 0) {
*op = kUpb_DecodeOp_UnknownField;
}
return upb_WireReader_ReadFixed32(ptr, &val->uint32_val);
case kUpb_WireType_64Bit:
*op = kUpb_DecodeOp_Scalar8Byte;
- if (((1 << field->descriptortype) & kFixed64OkMask) == 0) {
+ if (((1 << field->UPB_PRIVATE(descriptortype)) & kFixed64OkMask) == 0) {
*op = kUpb_DecodeOp_UnknownField;
}
return upb_WireReader_ReadFixed64(ptr, &val->uint64_val);
@@ -1067,10 +1068,11 @@
return ptr;
case kUpb_WireType_StartGroup:
val->uint32_val = field->number;
- if (field->descriptortype == kUpb_FieldType_Group) {
+ if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group) {
*op = kUpb_DecodeOp_SubMessage;
_upb_Decoder_CheckUnlinked(mt, field, op);
- } else if (field->descriptortype == kUpb_FakeFieldType_MessageSetItem) {
+ } else if (field->UPB_PRIVATE(descriptortype) ==
+ kUpb_FakeFieldType_MessageSetItem) {
*op = kUpb_DecodeOp_MessageSetItem;
} else {
*op = kUpb_DecodeOp_UnknownField;
diff --git a/upb/wire/encode.c b/upb/wire/encode.c
index c75bf6f..1a2182b 100644
--- a/upb/wire/encode.c
+++ b/upb/wire/encode.c
@@ -227,7 +227,7 @@
break; \
}
- switch (f->descriptortype) {
+ switch (f->UPB_PRIVATE(descriptortype)) {
case kUpb_FieldType_Double:
CASE(double, double, kUpb_WireType_64Bit, val);
case kUpb_FieldType_Float:
@@ -322,7 +322,7 @@
#define TAG(wire_type) (packed ? 0 : (f->number << 3 | wire_type))
- switch (f->descriptortype) {
+ switch (f->UPB_PRIVATE(descriptortype)) {
case kUpb_FieldType_Double:
encode_fixedarray(e, arr, sizeof(double), TAG(kUpb_WireType_64Bit));
break;
@@ -427,7 +427,8 @@
if (e->options & kUpb_EncodeOption_Deterministic) {
_upb_sortedmap sorted;
- _upb_mapsorter_pushmap(&e->sorter, layout->fields[0].descriptortype, map,
+ _upb_mapsorter_pushmap(&e->sorter,
+ layout->fields[0].UPB_PRIVATE(descriptortype), map,
&sorted);
upb_MapEntry ent;
while (_upb_sortedmap_next(&e->sorter, map, &sorted, &ent)) {
diff --git a/upbc/protoc-gen-upb.cc b/upbc/protoc-gen-upb.cc
index 71ebd7f..2f9b325 100644
--- a/upbc/protoc-gen-upb.cc
+++ b/upbc/protoc-gen-upb.cc
@@ -1021,13 +1021,16 @@
upb_MiniTable_FindFieldByNumber(mt, field.number());
std::string type = "";
std::string cardinality = "";
- switch (mt_f->descriptortype) {
+ switch (upb_MiniTableField_Type(mt_f)) {
case kUpb_FieldType_Bool:
type = "b1";
break;
case kUpb_FieldType_Enum:
- // We don't have the means to test proto2 enum fields for valid values.
- return false;
+ if (upb_MiniTableField_IsClosedEnum(mt_f)) {
+ // We don't have the means to test proto2 enum fields for valid values.
+ return false;
+ }
+ [[fallthrough]];
case kUpb_FieldType_Int32:
case kUpb_FieldType_UInt32:
type = "v4";
@@ -1266,7 +1269,7 @@
field64->UPB_PRIVATE(submsg_index) == kUpb_NoSub
? "kUpb_NoSub"
: absl::StrCat(field64->UPB_PRIVATE(submsg_index)).c_str(),
- field64->descriptortype, GetModeInit(field32, field64));
+ field64->UPB_PRIVATE(descriptortype), GetModeInit(field32, field64));
}
}
