upb: move IsOneof() from message/internal/accessors.h

PiperOrigin-RevId: 584358795

upb/message/accessors.h

@@ -66,7 +66,7 @@ UPB_API_INLINE bool upb_Message_HasField(const upb_Message* msg,
 
 UPB_API_INLINE uint32_t upb_Message_WhichOneofFieldNumber(
     const upb_Message* message, const upb_MiniTableField* oneof_field) {
-  UPB_ASSUME(_upb_MiniTableField_InOneOf(oneof_field));
+  UPB_ASSUME(upb_MiniTableField_IsInOneof(oneof_field));
   return _upb_Message_GetOneofCase(message, oneof_field);
 }
 

upb/message/internal/accessors.h

@@ -104,14 +104,14 @@ UPB_INLINE void _upb_Message_ClearHasbitByField(const upb_Message* msg,
 
 // Oneof case access ///////////////////////////////////////////////////////////
 
-UPB_INLINE size_t _upb_OneofCase_Offset(const upb_MiniTableField* f) {
+UPB_INLINE size_t _upb_MiniTableField_OneofOffset(const upb_MiniTableField* f) {
   UPB_ASSERT(f->presence < 0);
   return ~(ptrdiff_t)f->presence;
 }
 
 UPB_INLINE uint32_t* _upb_Message_OneofCasePtr(upb_Message* msg,
                                                const upb_MiniTableField* f) {
-  return UPB_PTR_AT(msg, _upb_OneofCase_Offset(f), uint32_t);
+  return UPB_PTR_AT(msg, _upb_MiniTableField_OneofOffset(f), uint32_t);
 }
 
 UPB_INLINE uint32_t _upb_Message_GetOneofCase(const upb_Message* msg,
@@ -128,10 +128,6 @@ UPB_INLINE void _upb_Message_SetOneofCase(upb_Message* msg,
 
 // LINT.ThenChange(GoogleInternalName2)
 
-UPB_INLINE bool _upb_MiniTableField_InOneOf(const upb_MiniTableField* field) {
-  return field->presence < 0;
-}
-
 UPB_INLINE void* _upb_MiniTableField_GetPtr(upb_Message* msg,
                                             const upb_MiniTableField* field) {
   return (char*)msg + field->offset;
@@ -146,7 +142,7 @@ UPB_INLINE void _upb_Message_SetPresence(upb_Message* msg,
                                          const upb_MiniTableField* field) {
   if (field->presence > 0) {
     _upb_Message_SetHasbitByField(msg, field);
-  } else if (_upb_MiniTableField_InOneOf(field)) {
+  } else if (upb_MiniTableField_IsInOneof(field)) {
     _upb_Message_SetOneofCase(msg, field);
   }
 }
@@ -237,7 +233,7 @@ UPB_INLINE bool _upb_Message_HasNonExtensionField(
     const upb_Message* msg, const upb_MiniTableField* field) {
   UPB_ASSERT(upb_MiniTableField_HasPresence(field));
   UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
-  if (_upb_MiniTableField_InOneOf(field)) {
+  if (upb_MiniTableField_IsInOneof(field)) {
     return _upb_Message_GetOneofCase(msg, field) == field->number;
   } else {
     return _upb_Message_GetHasbitByField(msg, field);
@@ -248,7 +244,7 @@ static UPB_FORCEINLINE void _upb_Message_GetNonExtensionField(
     const upb_Message* msg, const upb_MiniTableField* field,
     const void* default_val, void* val) {
   UPB_ASSUME(!upb_MiniTableField_IsExtension(field));
-  if ((_upb_MiniTableField_InOneOf(field) ||
+  if ((upb_MiniTableField_IsInOneof(field) ||
        _upb_MiniTable_ValueIsNonZero(default_val, field)) &&
       !_upb_Message_HasNonExtensionField(msg, field)) {
     _upb_MiniTable_CopyFieldData(val, default_val, field);
@@ -334,7 +330,7 @@ UPB_INLINE void _upb_Message_ClearNonExtensionField(
     upb_Message* msg, const upb_MiniTableField* field) {
   if (field->presence > 0) {
     _upb_Message_ClearHasbitByField(msg, field);
-  } else if (_upb_MiniTableField_InOneOf(field)) {
+  } else if (upb_MiniTableField_IsInOneof(field)) {
     uint32_t* ptr = _upb_Message_OneofCasePtr(msg, field);
     if (*ptr != field->number) return;
     *ptr = 0;

upb/message/promote.c

@@ -238,7 +238,7 @@ upb_UnknownToMessageRet upb_MiniTable_PromoteUnknownToMessage(
   // PromotoUnknownToMessage.
   UPB_ASSERT(upb_MiniTable_GetSubMessageTable(mini_table, field) ==
              sub_mini_table);
-  bool is_oneof = _upb_MiniTableField_InOneOf(field);
+  bool is_oneof = upb_MiniTableField_IsInOneof(field);
   if (!is_oneof || _upb_Message_GetOneofCase(msg, field) == field->number) {
     UPB_ASSERT(upb_Message_GetMessage(msg, field, NULL) == NULL);
   }

upb/mini_descriptor/internal/encode_test.cc

@@ -26,6 +26,7 @@
 #include "upb/mini_table/enum.h"
 #include "upb/mini_table/field.h"
 #include "upb/mini_table/internal/field.h"
+#include "upb/mini_table/internal/message.h"
 #include "upb/mini_table/message.h"
 
 // begin:google_only
@@ -152,7 +153,7 @@ TEST_P(MiniTableTest, AllScalarTypesOneof) {
     // For a oneof all fields have the same offset.
     EXPECT_EQ(table->fields[0].offset, f->offset);
     // All presence fields should point to the same oneof case offset.
-    size_t case_ofs = _upb_OneofCase_Offset(f);
+    size_t case_ofs = _upb_MiniTableField_OneofOffset(f);
     EXPECT_EQ(table->fields[0].presence, f->presence);
     EXPECT_TRUE(f->offset < table->size);
     EXPECT_TRUE(case_ofs < table->size);

upb/mini_table/field.h

@@ -8,32 +8,32 @@
 #ifndef UPB_MINI_TABLE_FIELD_H_
 #define UPB_MINI_TABLE_FIELD_H_
 
+#include <stddef.h>
+
 #include "upb/base/descriptor_constants.h"
 #include "upb/mini_table/internal/field.h"
-#include "upb/mini_table/internal/message.h"
-#include "upb/mini_table/internal/sub.h"
 
 // Must be last.
 #include "upb/port/def.inc"
 
+typedef struct upb_MiniTableField upb_MiniTableField;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct upb_MiniTableField upb_MiniTableField;
-
 UPB_API_INLINE upb_FieldType
-upb_MiniTableField_Type(const upb_MiniTableField* field) {
-  if (field->mode & kUpb_LabelFlags_IsAlternate) {
-    if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Int32) {
+upb_MiniTableField_Type(const upb_MiniTableField* f) {
+  if (f->mode & kUpb_LabelFlags_IsAlternate) {
+    if (f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Int32) {
       return kUpb_FieldType_Enum;
-    } else if (field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bytes) {
+    } else if (f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Bytes) {
       return kUpb_FieldType_String;
     } else {
       UPB_ASSERT(false);
     }
   }
-  return (upb_FieldType)field->UPB_PRIVATE(descriptortype);
+  return (upb_FieldType)f->UPB_PRIVATE(descriptortype);
 }
 
 UPB_API_INLINE upb_CType upb_MiniTableField_CType(const upb_MiniTableField* f) {
@@ -46,28 +46,32 @@ UPB_API_INLINE bool upb_MiniTableField_IsClosedEnum(
 }
 
 UPB_API_INLINE bool upb_MiniTableField_IsExtension(
-    const upb_MiniTableField* field) {
-  return field->mode & kUpb_LabelFlags_IsExtension;
+    const upb_MiniTableField* f) {
+  return f->mode & kUpb_LabelFlags_IsExtension;
+}
+
+UPB_API_INLINE bool upb_MiniTableField_IsInOneof(const upb_MiniTableField* f) {
+  return f->presence < 0;
 }
 
 UPB_API_INLINE bool upb_MiniTableField_IsRepeatedOrMap(
-    const upb_MiniTableField* field) {
+    const upb_MiniTableField* f) {
   // This works because upb_FieldMode has no value 3.
-  return !(field->mode & kUpb_FieldMode_Scalar);
+  return !(f->mode & kUpb_FieldMode_Scalar);
 }
 
 UPB_API_INLINE bool upb_MiniTableField_IsSubMessage(
-    const upb_MiniTableField* field) {
-  return field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Message ||
-         field->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group;
+    const upb_MiniTableField* f) {
+  return f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Message ||
+         f->UPB_PRIVATE(descriptortype) == kUpb_FieldType_Group;
 }
 
 UPB_API_INLINE bool upb_MiniTableField_HasPresence(
-    const upb_MiniTableField* field) {
-  if (upb_MiniTableField_IsExtension(field)) {
-    return !upb_MiniTableField_IsRepeatedOrMap(field);
+    const upb_MiniTableField* f) {
+  if (upb_MiniTableField_IsExtension(f)) {
+    return !upb_MiniTableField_IsRepeatedOrMap(f);
   } else {
-    return field->presence != 0;
+    return f->presence != 0;
   }
 }
 

upb/mini_table/message.h

@@ -11,6 +11,7 @@
 #include "upb/mini_table/enum.h"
 #include "upb/mini_table/field.h"
 #include "upb/mini_table/internal/message.h"
+#include "upb/mini_table/internal/sub.h"
 
 // Must be last.
 #include "upb/port/def.inc"