Access fields_ via helper in UnknownFieldSet.

This is in preparation for a change that will conditionally use a different container type for `fields_` in `UnknownFieldSet`.

PiperOrigin-RevId: 819441394

Author: ClaytonKnittel

src/google/protobuf/unknown_field_set.cc

@@ -36,22 +36,24 @@ namespace google {
 namespace protobuf {
 
 void UnknownFieldSet::ClearFallback() {
-  ABSL_DCHECK(!fields_.empty());
+  auto& fields = this->fields();
+  ABSL_DCHECK(!fields.empty());
   if (arena() == nullptr) {
-    int n = fields_.size();
+    int n = fields.size();
     do {
-      (fields_)[--n].Delete();
+      fields[--n].Delete();
     } while (n > 0);
   }
-  fields_.Clear();
+  fields.Clear();
 }
 
 void UnknownFieldSet::MergeFrom(const UnknownFieldSet& other) {
   int other_field_count = other.field_count();
   if (other_field_count > 0) {
-    fields_.Reserve(fields_.size() + other_field_count);
-    for (auto elem : other.fields_) {
-      fields_.Add(elem.DeepCopy(arena()));
+    auto& fields = this->fields();
+    fields.Reserve(fields.size() + other_field_count);
+    for (auto elem : other.fields()) {
+      fields.Add(elem.DeepCopy(arena()));
     }
   }
 }
@@ -61,11 +63,16 @@ void UnknownFieldSet::MergeFrom(const UnknownFieldSet& other) {
 void UnknownFieldSet::MergeFromAndDestroy(UnknownFieldSet* other) {
   if (arena() != other->arena()) {
     MergeFrom(*other);
-  } else if (fields_.empty()) {
-    fields_.Swap(&other->fields_);
+    return;
+  }
+
+  auto& fields = this->fields();
+  auto& other_fields = other->fields();
+  if (fields.empty()) {
+    fields.Swap(&other_fields);
   } else {
-    fields_.MergeFrom(other->fields_);
-    other->fields_.Clear();
+    fields.MergeFrom(other_fields);
+    other_fields.Clear();
   }
 }
 
@@ -75,11 +82,12 @@ void UnknownFieldSet::MergeToInternalMetadata(
 }
 
 size_t UnknownFieldSet::SpaceUsedExcludingSelfLong() const {
-  if (fields_.empty()) return 0;
+  auto& fields = this->fields();
+  if (fields.empty()) return 0;
 
-  size_t total_size = fields_.SpaceUsedExcludingSelfLong();
+  size_t total_size = fields.SpaceUsedExcludingSelfLong();
 
-  for (const UnknownField& field : fields_) {
+  for (const UnknownField& field : fields) {
     switch (field.type()) {
       case UnknownField::TYPE_LENGTH_DELIMITED:
         total_size += sizeof(*field.data_.string_value) +
@@ -101,21 +109,21 @@ size_t UnknownFieldSet::SpaceUsedLong() const {
 }
 
 void UnknownFieldSet::AddVarint(int number, uint64_t value) {
-  auto& field = *fields_.Add();
+  auto& field = *fields().Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_VARINT);
   field.data_.varint = value;
 }
 
 void UnknownFieldSet::AddFixed32(int number, uint32_t value) {
-  auto& field = *fields_.Add();
+  auto& field = *fields().Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_FIXED32);
   field.data_.fixed32 = value;
 }
 
 void UnknownFieldSet::AddFixed64(int number, uint64_t value) {
-  auto& field = *fields_.Add();
+  auto& field = *fields().Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_FIXED64);
   field.data_.fixed64 = value;
@@ -127,7 +135,7 @@ void UnknownFieldSet::AddLengthDelimited(int number, const absl::Cord& value) {
 
 template <int&...>
 void UnknownFieldSet::AddLengthDelimited(int number, std::string&& value) {
-  auto& field = *fields_.Add();
+  auto& field = *fields().Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_LENGTH_DELIMITED);
   field.data_.string_value =
@@ -136,51 +144,53 @@ void UnknownFieldSet::AddLengthDelimited(int number, std::string&& value) {
 template void UnknownFieldSet::AddLengthDelimited(int, std::string&&);
 
 std::string* UnknownFieldSet::AddLengthDelimited(int number) {
-  auto& field = *fields_.Add();
+  auto& field = *fields().Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_LENGTH_DELIMITED);
   field.data_.string_value = Arena::Create<std::string>(arena());
   return field.data_.string_value;
 }
 
 UnknownFieldSet* UnknownFieldSet::AddGroup(int number) {
-  auto& field = *fields_.Add();
+  auto& field = *fields().Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_GROUP);
   field.data_.group = Arena::Create<UnknownFieldSet>(arena());
   return field.data_.group;
 }
 
 void UnknownFieldSet::AddField(const UnknownField& field) {
-  fields_.Add(field.DeepCopy(arena()));
+  fields().Add(field.DeepCopy(arena()));
 }
 
 void UnknownFieldSet::DeleteSubrange(int start, int num) {
+  auto& fields = this->fields();
   if (arena() == nullptr) {
     // Delete the specified fields.
     for (int i = 0; i < num; ++i) {
-      (fields_)[i + start].Delete();
+      fields[i + start].Delete();
     }
   }
-  fields_.ExtractSubrange(start, num, nullptr);
+  fields.ExtractSubrange(start, num, nullptr);
 }
 
 void UnknownFieldSet::DeleteByNumber(int number) {
+  auto& fields = this->fields();
   int left = 0;  // The number of fields left after deletion.
-  for (int i = 0; i < fields_.size(); ++i) {
-    UnknownField* field = &(fields_)[i];
+  for (int i = 0; i < fields.size(); ++i) {
+    UnknownField* field = &fields[i];
     if (field->number() == number) {
       if (arena() == nullptr) {
         field->Delete();
       }
     } else {
       if (i != left) {
-        (fields_)[left] = (fields_)[i];
+        fields[left] = fields[i];
       }
       ++left;
     }
   }
-  fields_.Truncate(left);
+  fields.Truncate(left);
 }
 
 bool UnknownFieldSet::MergeFromCodedStream(io::CodedInputStream* input) {

src/google/protobuf/unknown_field_set.h

@@ -254,6 +254,9 @@ class PROTOBUF_EXPORT UnknownFieldSet {
 
   Arena* arena() { return fields_.GetArena(); }
 
+  const RepeatedField<UnknownField>& fields() const { return fields_; }
+  RepeatedField<UnknownField>& fields() { return fields_; }
+
   void ClearFallback();
   void SwapSlow(UnknownFieldSet* other);
 
@@ -332,31 +335,31 @@ inline const UnknownFieldSet& UnknownFieldSet::default_instance() {
 inline void UnknownFieldSet::ClearAndFreeMemory() { Clear(); }
 
 inline void UnknownFieldSet::Clear() {
-  if (!fields_.empty()) {
+  if (!fields().empty()) {
     ClearFallback();
   }
   if (v2_data_ != nullptr) v2_data_->clear();
 }
 
-inline bool UnknownFieldSet::empty() const { return fields_.empty(); }
+inline bool UnknownFieldSet::empty() const { return fields().empty(); }
 
 inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
   if (arena() == x->arena()) {
-    fields_.Swap(&x->fields_);
+    fields().Swap(&x->fields());
   } else {
     // We might need to do a deep copy, so use Merge instead
     SwapSlow(x);
   }
 }
 
 inline int UnknownFieldSet::field_count() const {
-  return static_cast<int>(fields_.size());
+  return static_cast<int>(fields().size());
 }
 inline const UnknownField& UnknownFieldSet::field(int index) const {
-  return (fields_)[static_cast<size_t>(index)];
+  return (fields())[static_cast<size_t>(index)];
 }
 inline UnknownField* UnknownFieldSet::mutable_field(int index) {
-  return &(fields_)[static_cast<size_t>(index)];
+  return &(fields())[static_cast<size_t>(index)];
 }
 
 inline void UnknownFieldSet::AddLengthDelimited(int number,