Internal change

PiperOrigin-RevId: 707187318

src/google/protobuf/parse_context.h

@@ -58,9 +58,9 @@ PROTOBUF_EXPORT void WriteVarint(uint32_t num, uint64_t val, std::string* s);
 PROTOBUF_EXPORT void WriteLengthDelimited(uint32_t num, absl::string_view val,
                                           std::string* s);
 // Inline because it is just forwarding to s->WriteVarint
-inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* s);
+inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* unknown);
 inline void WriteLengthDelimited(uint32_t num, absl::string_view val,
-                                 UnknownFieldSet* s);
+                                 UnknownFieldSet* unknown);
 
 
 // The basic abstraction the parser is designed for is a slight modification

src/google/protobuf/unknown_field_set.cc

@@ -11,6 +11,7 @@
 
 #include "google/protobuf/unknown_field_set.h"
 
+#include <cstdint>
 #include <cstring>
 #include <string>
 #include <utility>
@@ -23,11 +24,10 @@
 #include "google/protobuf/generated_message_tctable_impl.h"
 #include "google/protobuf/io/coded_stream.h"
 #include "google/protobuf/io/zero_copy_stream.h"
-#include "google/protobuf/io/zero_copy_stream_impl.h"
 #include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+#include "google/protobuf/message_lite.h"
 #include "google/protobuf/parse_context.h"
 #include "google/protobuf/wire_format.h"
-#include "google/protobuf/wire_format_lite.h"
 
 // Must be included last.
 #include "google/protobuf/port_def.inc"
@@ -87,7 +87,7 @@ size_t UnknownFieldSet::SpaceUsedExcludingSelfLong() const {
                           *field.data_.string_value);
         break;
       case UnknownField::TYPE_GROUP:
-        total_size += field.data_.group_->SpaceUsedLong();
+        total_size += field.data_.group->SpaceUsedLong();
         break;
       default:
         break;
@@ -104,21 +104,21 @@ void UnknownFieldSet::AddVarint(int number, uint64_t value) {
   auto& field = *fields_.Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_VARINT);
-  field.data_.varint_ = value;
+  field.data_.varint = value;
 }
 
 void UnknownFieldSet::AddFixed32(int number, uint32_t value) {
   auto& field = *fields_.Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_FIXED32);
-  field.data_.fixed32_ = value;
+  field.data_.fixed32 = value;
 }
 
 void UnknownFieldSet::AddFixed64(int number, uint64_t value) {
   auto& field = *fields_.Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_FIXED64);
-  field.data_.fixed64_ = value;
+  field.data_.fixed64 = value;
 }
 
 void UnknownFieldSet::AddLengthDelimited(int number, const absl::Cord& value) {
@@ -147,8 +147,8 @@ UnknownFieldSet* UnknownFieldSet::AddGroup(int number) {
   auto& field = *fields_.Add();
   field.number_ = number;
   field.SetType(UnknownField::TYPE_GROUP);
-  field.data_.group_ = Arena::Create<UnknownFieldSet>(arena());
-  return field.data_.group_;
+  field.data_.group = Arena::Create<UnknownFieldSet>(arena());
+  return field.data_.group;
 }
 
 void UnknownFieldSet::AddField(const UnknownField& field) {
@@ -166,8 +166,8 @@ void UnknownFieldSet::DeleteSubrange(int start, int num) {
 }
 
 void UnknownFieldSet::DeleteByNumber(int number) {
-  size_t left = 0;  // The number of fields left after deletion.
-  for (size_t i = 0; i < fields_.size(); ++i) {
+  int left = 0;  // The number of fields left after deletion.
+  for (int i = 0; i < fields_.size(); ++i) {
     UnknownField* field = &(fields_)[i];
     if (field->number() == number) {
       if (arena() == nullptr) {
@@ -243,7 +243,7 @@ void UnknownField::Delete() {
       delete data_.string_value;
       break;
     case UnknownField::TYPE_GROUP:
-      delete data_.group_;
+      delete data_.group;
       break;
     default:
       break;
@@ -259,8 +259,8 @@ UnknownField UnknownField::DeepCopy(Arena* arena) const {
       break;
     case UnknownField::TYPE_GROUP: {
       UnknownFieldSet* group = Arena::Create<UnknownFieldSet>(arena);
-      group->MergeFrom(*data_.group_);
-      copy.data_.group_ = group;
+      group->MergeFrom(*data_.group);
+      copy.data_.group = group;
       break;
     }
     default:

src/google/protobuf/unknown_field_set.h

@@ -17,14 +17,17 @@
 
 #include <assert.h>
 
-#include <atomic>
+#include <cstddef>
+#include <cstdint>
 #include <string>
+#include <type_traits>
+#include <utility>
 
-#include "google/protobuf/stubs/common.h"
 #include "absl/log/absl_check.h"
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/arena.h"
+#include "google/protobuf/internal_visibility.h"
 #include "google/protobuf/io/coded_stream.h"
 #include "google/protobuf/io/zero_copy_stream_impl_lite.h"
 #include "google/protobuf/message_lite.h"
@@ -118,11 +121,11 @@ class PROTOBUF_EXPORT UnknownField {
   uint32_t number_;
   uint32_t type_;
   union {
-    uint64_t varint_;
-    uint32_t fixed32_;
-    uint64_t fixed64_;
+    uint64_t varint;
+    uint32_t fixed32;
+    uint64_t fixed64;
     std::string* string_value;
-    UnknownFieldSet* group_;
+    UnknownFieldSet* group;
   } data_;
 };
 
@@ -268,8 +271,8 @@ class PROTOBUF_EXPORT UnknownFieldSet {
   void SwapSlow(UnknownFieldSet* other);
 
   template <typename MessageType,
-            typename std::enable_if<
-                std::is_base_of<Message, MessageType>::value, int>::type = 0>
+            typename std::enable_if_t<
+                std::is_base_of<Message, MessageType>::value, int> = 0>
   bool InternalMergeFromMessage(const MessageType& message) {
     MergeFrom(message.GetReflection()->GetUnknownFields(message));
     return true;
@@ -364,36 +367,36 @@ inline UnknownField::Type UnknownField::type() const {
 
 inline uint64_t UnknownField::varint() const {
   assert(type() == TYPE_VARINT);
-  return data_.varint_;
+  return data_.varint;
 }
 inline uint32_t UnknownField::fixed32() const {
   assert(type() == TYPE_FIXED32);
-  return data_.fixed32_;
+  return data_.fixed32;
 }
 inline uint64_t UnknownField::fixed64() const {
   assert(type() == TYPE_FIXED64);
-  return data_.fixed64_;
+  return data_.fixed64;
 }
 inline internal::UFSStringView UnknownField::length_delimited() const {
   assert(type() == TYPE_LENGTH_DELIMITED);
   return *data_.string_value;
 }
 inline const UnknownFieldSet& UnknownField::group() const {
   assert(type() == TYPE_GROUP);
-  return *data_.group_;
+  return *data_.group;
 }
 
 inline void UnknownField::set_varint(uint64_t value) {
   assert(type() == TYPE_VARINT);
-  data_.varint_ = value;
+  data_.varint = value;
 }
 inline void UnknownField::set_fixed32(uint32_t value) {
   assert(type() == TYPE_FIXED32);
-  data_.fixed32_ = value;
+  data_.fixed32 = value;
 }
 inline void UnknownField::set_fixed64(uint64_t value) {
   assert(type() == TYPE_FIXED64);
-  data_.fixed64_ = value;
+  data_.fixed64 = value;
 }
 inline void UnknownField::set_length_delimited(const absl::string_view value) {
   assert(type() == TYPE_LENGTH_DELIMITED);
@@ -416,7 +419,7 @@ inline std::string* UnknownField::mutable_length_delimited() {
 #endif  // PROTOBUF_FUTURE_STRING_VIEW_RETURN_TYPE
 inline UnknownFieldSet* UnknownField::mutable_group() {
   assert(type() == TYPE_GROUP);
-  return data_.group_;
+  return data_.group;
 }
 template <typename MessageType>
 bool UnknownFieldSet::MergeFromMessage(const MessageType& message) {