protovalidate 0.1.0.beta1

data/ext/protovalidate/sys/third_party/protobuf/src/google/protobuf/repeated_field.h

@@ -0,0 +1,1814 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// RepeatedField and RepeatedPtrField are used by generated protocol message
+// classes to manipulate repeated fields.  These classes are very similar to
+// STL's vector, but include a number of optimizations found to be useful
+// specifically in the case of Protocol Buffers.  RepeatedPtrField is
+// particularly different from STL vector as it manages ownership of the
+// pointers that it contains.
+//
+// This header covers RepeatedField.
+
+#ifndef GOOGLE_PROTOBUF_REPEATED_FIELD_H__
+#define GOOGLE_PROTOBUF_REPEATED_FIELD_H__
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/macros.h"
+#include "absl/base/no_destructor.h"
+#include "absl/base/optimization.h"
+#include "absl/log/absl_check.h"
+#include "absl/strings/cord.h"
+#include "google/protobuf/arena.h"
+#include "google/protobuf/arena_align.h"
+#include "google/protobuf/field_with_arena.h"
+#include "google/protobuf/generated_enum_util.h"
+#include "google/protobuf/internal_metadata_locator.h"
+#include "google/protobuf/internal_visibility.h"
+#include "google/protobuf/message_lite.h"
+#include "google/protobuf/port.h"
+#include "google/protobuf/repeated_ptr_field.h"
+#include "google/protobuf/serial_arena.h"
+
+// Must be included last.
+#include "google/protobuf/port_def.inc"
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+
+namespace google {
+namespace protobuf {
+
+class Message;
+class DynamicMessage;
+class UnknownField;  // For the allowlist
+class UnknownFieldSet;
+class DynamicMessage;
+class Reflection;
+template <typename ElementType>
+class RepeatedFieldProxy;
+
+namespace internal {
+
+class EpsCopyInputStream;
+class TcParser;
+class WireFormat;
+
+template <typename T, int kHeapRepHeaderSize>
+constexpr int RepeatedFieldLowerClampLimit() {
+  // The header is padded to be at least `sizeof(T)` when it would be smaller
+  // otherwise.
+  static_assert(sizeof(T) <= kHeapRepHeaderSize, "");
+  // We want to pad the minimum size to be a power of two bytes, including the
+  // header.
+  // The first allocation is kHeapRepHeaderSize bytes worth of elements for a
+  // total of 2*kHeapRepHeaderSize bytes. For an 8-byte header, we allocate 8
+  // bool, 2 ints, or 1 int64.
+  return kHeapRepHeaderSize / sizeof(T);
+}
+
+// kRepeatedFieldUpperClampLimit is the lowest signed integer value that
+// overflows when multiplied by 2 (which is undefined behavior). Sizes above
+// this will clamp to the maximum int value instead of following exponential
+// growth when growing a repeated field.
+#if defined(__cpp_inline_variables)
+inline constexpr int kRepeatedFieldUpperClampLimit =
+#else
+constexpr int kRepeatedFieldUpperClampLimit =
+#endif
+    (std::numeric_limits<int>::max() / 2) + 1;
+
+template <typename Element>
+class RepeatedIterator;
+
+// Sentinel base class.
+struct RepeatedFieldBase {};
+
+// Decays `Element` to a value type (excluding `absl::Cord` in release builds
+// to avoid a nontrivial copy). This is useful when forwarding element values
+// to user-provided callbacks, which prevents leaking a reference to the
+// backing storage of the repeated field.
+template <typename Element>
+using DecayedRepeatedFieldElement =
+    std::conditional_t<std::is_same_v<Element, absl::Cord> &&
+                           !internal::PerformDebugChecks(),
+                       const Element&, Element>;
+
+// Align to 8 as sanitizers are picky on the alignment of containers to start at
+// 8 byte offsets even when compiling for 32 bit platforms.
+template <size_t kMinSize>
+class alignas(8) HeapRep {
+ public:
+  explicit HeapRep(uint32_t capacity) : capacity_(capacity), unused_(0) {}
+  // Avoid 'implicitly deleted dtor' warnings on certain compilers.
+  ~HeapRep() = delete;
+
+  uint32_t capacity() const { return capacity_; }
+
+  const void* elements() const { return elements_; }
+  void* elements() { return elements_; }
+
+  // Returns the size of the HeapRep in bytes. Do not use `sizeof(HeapRep)`,
+  // since that includes the dummy `elements_` member.
+  static constexpr size_t SizeOf() { return offsetof(HeapRep, elements_); }
+
+ private:
+  union {
+    struct {
+      uint32_t capacity_;
+      [[maybe_unused]] const uint32_t unused_;
+    };
+
+    // We pad the header to be at least `sizeof(Element)` so that we have
+    // power-of-two sized allocations, which enables Arena optimizations.
+    char padding_[kMinSize];
+  };
+
+  // This is the start of the elements storage. We would use a flexible array
+  // member here, but that's not available in all compilers. We will not
+  // initialize this member, and `kHeapRepHeaderSize` ignores this field.
+  uint8_t elements_[1];
+};
+
+// We use small object optimization (SOO) to store elements inline when possible
+// for small repeated fields. We do so in order to avoid memory indirections.
+// Note that SOO is disabled on 32-bit platforms due to alignment limitations.
+
+// SOO data is stored in the same space as the size/capacity ints.
+enum { kSooCapacityBytes = 2 * sizeof(int) };
+
+inline constexpr uint32_t kNotSooBit = 0x1;
+// The number of bits at the start of the `InternalMetadataResolver` offset to
+// use for other purposes. Note that this must be <= log2(alignof(void*)).
+inline constexpr uint32_t kResolverTaggedBits = 1;
+inline constexpr size_t kSooSizeMask = sizeof(void*);
+
+// The number of elements that can be stored in the SOO rep. On 64-bit
+// platforms, this is 1 for int64_t, 2 for int32_t, 3 for bool, and 0 for
+// absl::Cord. We return 0 to disable SOO on 32-bit platforms.
+template <typename T>
+constexpr int SooCapacityElements() {
+  // RepeatedPtrField always has SOO capacity of 1.
+  if constexpr (std::is_pointer_v<T>) {
+    return 1;
+  }
+  // Disable SOO for RepeatedFields on 32-bit platforms.
+  if constexpr (sizeof(void*) < 8) return 0;
+  return std::min<int>(kSooCapacityBytes / sizeof(T), kSooSizeMask);
+}
+
+template <size_t kMinSize>
+class SooRep {
+ public:
+  constexpr SooRep() = default;
+  explicit constexpr SooRep(InternalMetadataOffset offset)
+      : resolver_(offset) {}
+
+  bool is_soo() const { return (resolver_.Tag() & kNotSooBit) == 0; }
+  Arena* arena() const {
+    return ResolveTaggedArena<&SooRep::resolver_, kResolverTaggedBits>(this);
+  }
+  int size() const { return size_; }
+  void set_size(int size) {
+    ABSL_DCHECK(!is_soo() || size <= kSooCapacityBytes);
+    size_ = size;
+  }
+  int capacity() const {
+    ABSL_DCHECK(!this->is_soo());
+    return heap_rep_->capacity();
+  }
+  // Initializes the SooRep in non-SOO mode with the given heap allocation.
+  void set_non_soo(HeapRep<kMinSize>* heap_rep) {
+    resolver_.SetTag(kNotSooBit);
+    heap_rep_ = heap_rep;
+  }
+
+  HeapRep<kMinSize>* heap_rep() const {
+    ABSL_DCHECK(!is_soo());
+    return heap_rep_;
+  }
+
+  const void* elements(bool is_soo) const {
+    ABSL_DCHECK_EQ(is_soo, this->is_soo());
+    if (is_soo) {
+      return soo_data_;
+    } else {
+      return heap_rep_->elements();
+    }
+  }
+
+  void* elements(bool is_soo) {
+    ABSL_DCHECK_EQ(is_soo, this->is_soo());
+    if (is_soo) {
+      return soo_data_;
+    } else {
+      return heap_rep_->elements();
+    }
+  }
+
+  void swap(SooRep& other) {
+    resolver_.SwapTags(other.resolver_);
+    internal::memswap<sizeof(SooRep) - offsetof(SooRep, size_)>(
+        reinterpret_cast<char*>(&this->size_),
+        reinterpret_cast<char*>(&other.size_));
+  }
+
+ private:
+  TaggedInternalMetadataResolver<kResolverTaggedBits> resolver_;
+  uint32_t size_ = 0;
+  union {
+    char soo_data_[kSooCapacityBytes];
+    HeapRep<kMinSize>* heap_rep_;
+
+    // NOTE: in some language versions, we can't have a constexpr constructor
+    // if we don't initialize all fields, but we don't need to initialize this
+    // field, so initialize an empty dummy variable instead.
+    std::true_type dummy_ = {};
+  };
+};
+
+}  // namespace internal
+
+// RepeatedField is used to represent repeated fields of a primitive type (in
+// other words, everything except strings and nested Messages).  Most users will
+// not ever use a RepeatedField directly; they will use the get-by-index,
+// set-by-index, and add accessors that are generated for all repeated fields.
+// Actually, in addition to primitive types, we use RepeatedField for repeated
+// Cords, because the Cord class is in fact just a reference-counted pointer.
+// We have to specialize several methods in the Cord case to get the memory
+// management right; e.g. swapping when appropriate, etc.
+template <typename Element>
+class ABSL_ATTRIBUTE_WARN_UNUSED PROTOBUF_DECLSPEC_EMPTY_BASES
+    RepeatedField final
+    : private internal::RepeatedFieldBase,
+      private internal::ContainerDestructorSkippableBase<Element> {
+  static_assert(
+      alignof(Arena) >= alignof(Element),
+      "We only support types that have an alignment smaller than Arena");
+  static_assert(!std::is_const<Element>::value,
+                "We do not support const value types.");
+  static_assert(!std::is_volatile<Element>::value,
+                "We do not support volatile value types.");
+  static_assert(!std::is_pointer<Element>::value,
+                "We do not support pointer value types.");
+  static_assert(!std::is_reference<Element>::value,
+                "We do not support reference value types.");
+  static constexpr PROTOBUF_ALWAYS_INLINE void StaticValidityCheck() {
+    static_assert(
+        std::disjunction<internal::is_supported_integral_type<Element>,
+                         internal::is_supported_floating_point_type<Element>,
+                         std::is_same<absl::Cord, Element>,
+                         std::is_same<UnknownField, Element>,
+                         is_proto_enum<Element>>::value,
+        "We only support non-string scalars in RepeatedField.");
+  }
+
+ public:
+  using value_type = Element;
+  using size_type = int;
+  using difference_type = ptrdiff_t;
+  using reference = Element&;
+  using const_reference = const Element&;
+  using pointer = Element*;
+  using const_pointer = const Element*;
+  using iterator = internal::RepeatedIterator<Element>;
+  using const_iterator = internal::RepeatedIterator<const Element>;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  constexpr RepeatedField();
+  RepeatedField(const RepeatedField& rhs)
+      : RepeatedField(internal::InternalMetadataOffset(), rhs) {}
+
+  template <typename Iter,
+            typename = typename std::enable_if<std::is_constructible<
+                Element, decltype(*std::declval<Iter>())>::value>::type>
+  RepeatedField(Iter begin, Iter end);
+
+  // Arena enabled constructors: for internal use only.
+  constexpr RepeatedField(internal::InternalVisibility,
+                          internal::InternalMetadataOffset offset)
+      : RepeatedField(offset) {}
+  RepeatedField(internal::InternalVisibility,
+                internal::InternalMetadataOffset offset,
+                const RepeatedField& rhs)
+      : RepeatedField(offset, rhs) {}
+
+  RepeatedField& operator=(const RepeatedField& other)
+      ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  RepeatedField(RepeatedField&& rhs) noexcept
+      : RepeatedField(internal::InternalMetadataOffset(), std::move(rhs)) {}
+  RepeatedField& operator=(RepeatedField&& other) noexcept
+      ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  ~RepeatedField();
+
+  PROTOBUF_FUTURE_ADD_NODISCARD bool empty() const;
+  PROTOBUF_FUTURE_ADD_NODISCARD int size() const;
+
+  PROTOBUF_FUTURE_ADD_NODISCARD const_reference
+  Get(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD pointer Mutable(int index)
+      ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  PROTOBUF_FUTURE_ADD_NODISCARD const_reference
+  operator[](int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return Get(index);
+  }
+  PROTOBUF_FUTURE_ADD_NODISCARD reference operator[](int index)
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return *Mutable(index);
+  }
+
+  PROTOBUF_FUTURE_ADD_NODISCARD const_reference
+  at(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD reference at(int index)
+      ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  void Set(int index, const Element& value);
+  void Add(Element value);
+
+  // Appends a new element and returns a pointer to it.
+  // The new element is uninitialized if |Element| is a POD type.
+  pointer Add() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  // Appends elements in the range [begin, end) after reserving
+  // the appropriate number of elements.
+  template <typename Iter>
+  void Add(Iter begin, Iter end);
+
+  // The following APIs are for internal use only.
+  template <typename ArenaProvider>
+  void InternalAddWithArena(internal::InternalVisibility,
+                            ArenaProvider arena_provider, Element value);
+  template <typename ArenaProvider>
+  pointer InternalAddWithArena(internal::InternalVisibility,
+                               ArenaProvider arena_provider)
+      ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // Removes the last element in the array.
+  void RemoveLast();
+
+  // Extracts elements with indices in "[start .. start+num-1]".
+  // Copies them into "elements[0 .. num-1]" if "elements" is not nullptr.
+  // Caution: also moves elements with indices [start+num ..].
+  // Calling this routine inside a loop can cause quadratic behavior.
+  void ExtractSubrange(int start, int num, Element* elements);
+
+  ABSL_ATTRIBUTE_REINITIALIZES void Clear();
+
+  // Appends the elements from `other` after this instance.
+  // The end result length will be `other.size() + this->size()`.
+  void MergeFrom(const RepeatedField& other);
+
+  // Replaces the contents with a copy of the elements from `other`.
+  ABSL_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedField& other);
+
+  // Replaces the contents with RepeatedField(begin, end).
+  template <typename Iter>
+  ABSL_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);
+
+  // Reserves space to expand the field to at least the given size.  If the
+  // array is grown, it will always be at least doubled in size.
+  void Reserve(int new_size);
+
+  // Resizes the RepeatedField to a new, smaller size.  This is O(1).
+  // Except for RepeatedField<Cord>, for which it is O(size-new_size).
+  void Truncate(int new_size);
+
+  void AddAlreadyReserved(Element value);
+  PROTOBUF_FUTURE_ADD_NODISCARD int Capacity() const;
+
+  // Adds `n` elements to this instance asserting there is enough capacity.
+  // The added elements are uninitialized if `Element` is trivial.
+  pointer AddAlreadyReserved() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  pointer AddNAlreadyReserved(int n) ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  ABSL_DEPRECATE_AND_INLINE()
+  void Resize(size_type new_size, const Element& value);
+
+  // Like STL resize.  Uses value to fill appended elements.
+  // Like Truncate() if new_size <= size(), otherwise this is
+  // O(new_size - size()).
+  void resize(size_type new_size);
+  void resize(size_type new_size, const Element& value);
+
+  // Gets the underlying array.  This pointer is possibly invalidated by
+  // any add or remove operation.
+  PROTOBUF_FUTURE_ADD_NODISCARD pointer mutable_data()
+      ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD const_pointer
+  data() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // Swaps entire contents with "other". If they are separate arenas, then
+  // copies data between each other.
+  void Swap(RepeatedField* other);
+
+  // Swaps two elements.
+  void SwapElements(int index1, int index2);
+
+  PROTOBUF_FUTURE_ADD_NODISCARD iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD const_iterator
+  begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD const_iterator
+  cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD const_iterator
+  end() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  PROTOBUF_FUTURE_ADD_NODISCARD const_iterator
+  cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // Reverse iterator support
+  PROTOBUF_FUTURE_ADD_NODISCARD reverse_iterator rbegin()
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return reverse_iterator(end());
+  }
+  PROTOBUF_FUTURE_ADD_NODISCARD const_reverse_iterator
+  rbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return const_reverse_iterator(end());
+  }
+  PROTOBUF_FUTURE_ADD_NODISCARD reverse_iterator rend()
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return reverse_iterator(begin());
+  }
+  PROTOBUF_FUTURE_ADD_NODISCARD const_reverse_iterator
+  rend() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+    return const_reverse_iterator(begin());
+  }
+
+  // Returns the number of bytes used by the repeated field, excluding
+  // sizeof(*this)
+  PROTOBUF_FUTURE_ADD_NODISCARD size_t SpaceUsedExcludingSelfLong() const;
+
+  PROTOBUF_FUTURE_ADD_NODISCARD int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+  // Removes the element referenced by position.
+  //
+  // Returns an iterator to the element immediately following the removed
+  // element.
+  //
+  // Invalidates all iterators at or after the removed element, including end().
+  iterator erase(const_iterator position) ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // Removes the elements in the range [first, last).
+  //
+  // Returns an iterator to the element immediately following the removed range.
+  //
+  // Invalidates all iterators at or after the removed range, including end().
+  iterator erase(const_iterator first,
+                 const_iterator last) ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // Gets the Arena on which this RepeatedField stores its elements.
+  PROTOBUF_FUTURE_ADD_NODISCARD inline Arena* GetArena() {
+    // Note: we make this function non-const to force callers to call the
+    // `mutable_*` accessor on the repeated field before calling `GetArena()`,
+    // which initializes the field if it is split. If this method were const,
+    // then `msg.repeated_field().GetArena()` would be valid, but for split
+    // repeated fields `repeated_field()` could point to the default split
+    // instance. This would always return `nullptr`, which is incorrect when
+    // using arenas.
+    return soo_rep_.arena();
+  }
+
+  // For internal use only.
+  //
+  // This is public due to it being called by generated code.
+  inline void InternalSwap(RepeatedField* other);
+
+ private:
+  using InternalArenaConstructable_ = void;
+  // We use std::max in order to share template instantiations between
+  // different element types.
+  static constexpr size_t kMinHeapRepSize =
+      std::max<size_t>(sizeof(Element), 8);
+  using HeapRep = internal::HeapRep<kMinHeapRepSize>;
+
+  template <typename T>
+  friend class Arena::InternalHelper;
+
+  friend class Arena;
+
+  friend class DynamicMessage;
+
+  friend class internal::FieldWithArena<RepeatedField<Element>>;
+
+  // For access to private `*WithArena` functions.
+  friend class google::protobuf::Reflection;
+  friend class internal::EpsCopyInputStream;
+  friend class internal::TcParser;
+  friend class internal::WireFormat;
+
+  friend class RepeatedFieldProxy<Element>;
+
+  // For access to private arena constructor.
+  friend class UnknownFieldSet;
+
+  static constexpr int kSooCapacityElements =
+      internal::SooCapacityElements<Element>();
+
+  static constexpr int kInitialSize = 0;
+  static constexpr const size_t kHeapRepHeaderSize = HeapRep::SizeOf();
+
+  explicit constexpr RepeatedField(internal::InternalMetadataOffset offset);
+  RepeatedField(internal::InternalMetadataOffset offset,
+                const RepeatedField& rhs);
+  RepeatedField(internal::InternalMetadataOffset offset, RepeatedField&& rhs);
+
+  template <typename Init>
+  void ResizeImpl(int new_size, Init init);
+
+  internal::SerialArena* GetSerialArena() { return ResolveArena(GetArena()); }
+
+  template <typename T>
+  auto ResolveArena(T provider) {
+    return internal::GetSerialArena(provider);
+  }
+  // Passing `SelfArena{}` is equivalent to `this`, but it avoids an extra
+  // parameter in the ABI. We don't need to duplicate the `this` parameter.
+  struct SelfArena {};
+  auto ResolveArena(SelfArena) { return GetSerialArena(); }
+
+  bool is_soo() const { return soo_rep_.is_soo(); }
+  void set_size(int size) {
+    ABSL_DCHECK_LE(size, Capacity());
+    soo_rep_.set_size(size);
+  }
+  int Capacity(bool is_soo) const {
+    return is_soo ? kSooCapacityElements : soo_rep_.capacity();
+  }
+
+  template <typename ArenaProvider>
+  void ReserveWithArena(ArenaProvider arena_provider, int new_size);
+  void GrowByWithArena(Arena* arena, int grow_by) {
+    ReserveWithArena(arena, size() + grow_by);
+  }
+
+  template <typename ArenaProvider>
+  void* AddUninitializedWithArena(ArenaProvider arena_provider);
+
+  template <typename ArenaProvider>
+  pointer AddWithArena(ArenaProvider arena_provider, Element value);
+  template <typename ArenaProvider>
+  pointer AddWithArena(ArenaProvider arena_provider)
+      ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  template <typename ArenaProvider, typename Iter>
+  void AddWithArena(ArenaProvider arena_provider, Iter begin, Iter end);
+
+  // Private-only API for in-place construction of elements in the repeated
+  // field.
+  template <typename... Args>
+  pointer EmplaceWithArena(Arena* arena, Args&&... args);
+
+  void SwapFallbackWithTemp(Arena* arena, RepeatedField& other,
+                            Arena* other_arena, RepeatedField<Element>& temp);
+
+  // Swaps entire contents with "other". Should be called only if the caller can
+  // guarantee that both repeated fields are on the same arena or are on the
+  // heap. Swapping between different arenas is disallowed and caught by a
+  // ABSL_DCHECK (see API docs for details).
+  void UnsafeArenaSwap(RepeatedField* other);
+
+  // Copy constructs `n` instances in place into the array `dst`.
+  // This function is identical to `std::uninitialized_copy_n(src, n, dst)`
+  // except that we explicit declare the memory to not be aliased, which will
+  // result in `memcpy` code generation instead of `memmove` for trivial types.
+  static inline void UninitializedCopyN(const Element* PROTOBUF_RESTRICT src,
+                                        int n, Element* PROTOBUF_RESTRICT dst) {
+    std::uninitialized_copy_n(src, n, dst);
+  }
+
+  // Copy constructs `[begin, end)` instances in place into the array `dst`.
+  // See above `UninitializedCopyN()` function comments for more information.
+  template <typename Iter>
+  static inline void UninitializedCopy(Iter begin, Iter end,
+                                       Element* PROTOBUF_RESTRICT dst) {
+    std::uninitialized_copy(begin, end, dst);
+  }
+
+  // Destroys all elements in [begin, end).
+  // This function does nothing if `Element` is trivial.
+  static void Destroy([[maybe_unused]] const Element* begin,
+                      [[maybe_unused]] const Element* end) {
+    if constexpr (!std::is_trivially_destructible<Element>::value) {
+      std::for_each(begin, end, [&](const Element& e) { e.~Element(); });
+    }
+  }
+
+  template <typename ArenaProvider, typename Iter>
+  void AddForwardIterator(ArenaProvider arena_provider, Iter begin, Iter end);
+
+  template <typename ArenaProvider, typename Iter>
+  void AddInputIterator(ArenaProvider arena_provider, Iter begin, Iter end);
+
+  // Reserves space to expand the field to at least the given size.
+  // If the array is grown, it will always be at least doubled in size.
+  // If `annotate_size` is true (the default), then this function will annotate
+  // the old container from `old_size` to `Capacity()` (unpoison memory)
+  // directly before it is being released, and annotate the new container from
+  // `Capacity()` to `old_size` (poison unused memory).
+  template <typename ArenaProvider>
+  void Grow(ArenaProvider arena_provider, bool was_soo, int old_size,
+            int new_size);
+  template <typename ArenaProvider>
+  void GrowNoAnnotate(ArenaProvider arena_provider, bool was_soo, int old_size,
+                      int new_size);
+
+  // Annotates a change in size of this instance. This function should be called
+  // with (capacity, old_size) after new memory has been allocated and filled
+  // from previous memory.
+  void AnnotateSize(int old_size, int new_size) const {
+    if (old_size != new_size) {
+      [[maybe_unused]] const bool is_soo = this->is_soo();
+      [[maybe_unused]] const Element* elem =
+          reinterpret_cast<const Element*>(soo_rep_.elements(is_soo));
+      ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(elem, elem + Capacity(is_soo),
+                                         elem + old_size, elem + new_size);
+      if (new_size < old_size) {
+        ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(
+            elem + new_size, (old_size - new_size) * sizeof(Element));
+      }
+    }
+  }
+
+  // This should be called right before (previously annotated) memory is
+  // released.
+  void AnnotateForRelease() const { AnnotateSize(size(), Capacity()); }
+
+  // Replaces size with new_size and returns the previous value of
+  // size. This function is intended to be the only place where
+  // size is modified, with the exception of `AddInputIterator()`
+  // where the size of added items is not known in advance.
+  inline int ExchangeCurrentSize(int new_size) {
+    const int prev_size = size();
+    AnnotateSize(prev_size, new_size);
+    set_size(new_size);
+    return prev_size;
+  }
+
+  // Returns a pointer to elements array.
+  // pre-condition: Capacity() > 0.
+  Element* elements(bool is_soo) {
+    ABSL_DCHECK_GT(Capacity(is_soo), 0);
+    return unsafe_elements(is_soo);
+  }
+  const Element* elements(bool is_soo) const {
+    return const_cast<RepeatedField*>(this)->elements(is_soo);
+  }
+
+  // Returns a pointer to elements array if it exists; otherwise an invalid
+  // pointer is returned. This only happens for empty repeated fields, where you
+  // can't dereference this pointer anyway (it's empty).
+  Element* unsafe_elements(bool is_soo) {
+    return reinterpret_cast<Element*>(soo_rep_.elements(is_soo));
+  }
+  const Element* unsafe_elements(bool is_soo) const {
+    return const_cast<RepeatedField*>(this)->unsafe_elements(is_soo);
+  }
+
+  // Returns a pointer to the HeapRep struct.
+  // pre-condition: the HeapRep must have been allocated, ie !is_soo().
+  HeapRep* heap_rep() const {
+    ABSL_DCHECK(!is_soo());
+    return soo_rep_.heap_rep();
+  }
+
+  // Internal helper to delete all elements and deallocate the storage.
+  template <bool in_destructor = false, typename ArenaProvider>
+  void InternalDeallocate(ArenaProvider arena_provider) {
+    ABSL_DCHECK(!is_soo());
+    ABSL_DCHECK_EQ(ResolveArena(arena_provider), GetSerialArena());
+    const size_t bytes = Capacity(false) * sizeof(Element) + kHeapRepHeaderSize;
+    if constexpr (in_destructor &&
+                  Arena::is_destructor_skippable<RepeatedField>::value) {
+      // Repeated fields with destructor-skippable elements are never destroyed
+      // during arena cleanup.
+      ABSL_DCHECK_EQ(GetArena(), nullptr);
+      internal::SizedDelete(heap_rep(), bytes);
+    } else {
+      auto* arena = ResolveArena(arena_provider);
+      if (arena == nullptr) {
+        internal::SizedDelete(heap_rep(), bytes);
+      } else if (!in_destructor) {
+        // If we are in the destructor, we might be being destroyed as part of
+        // the arena teardown. We can't try and return blocks to the arena then.
+        arena->ReturnArrayMemory(heap_rep(), bytes);
+      }
+    }
+  }
+
+  // A note on the representation here (see also comment below for
+  // RepeatedPtrFieldBase's struct HeapRep):
+  //
+  // We maintain the same sizeof(RepeatedField) as before we added arena support
+  // so that we do not degrade performance by bloating memory usage. Directly
+  // adding an arena_ element to RepeatedField is quite costly. By using
+  // indirection in this way, we keep the same size when the RepeatedField is
+  // empty (common case), and add only an 8-byte header to the elements array
+  // when non-empty. We make sure to place the size fields directly in the
+  // RepeatedField class to avoid costly cache misses due to the indirection.
+  internal::SooRep<kMinHeapRepSize> soo_rep_;
+};
+
+namespace internal {
+
+template <typename Element>
+using RepeatedFieldWithArena = internal::FieldWithArena<RepeatedField<Element>>;
+
+template <typename Element>
+struct FieldArenaRep<RepeatedField<Element>> {
+  using Type = RepeatedFieldWithArena<Element>;
+
+  static RepeatedField<Element>* Get(Type* arena_rep) {
+    return &arena_rep->field();
+  }
+};
+
+template <typename Element>
+struct FieldArenaRep<const RepeatedField<Element>> {
+  using Type = const RepeatedFieldWithArena<Element>;
+
+  static const RepeatedField<Element>* Get(Type* arena_rep) {
+    return &arena_rep->field();
+  }
+};
+
+}  // namespace internal
+
+// implementation ====================================================
+
+template <typename Element>
+constexpr RepeatedField<Element>::RepeatedField() {
+  StaticValidityCheck();
+#ifdef __cpp_lib_is_constant_evaluated
+  if (!std::is_constant_evaluated()) {
+    AnnotateSize(kSooCapacityElements, 0);
+  }
+#endif  // __cpp_lib_is_constant_evaluated
+}
+
+template <typename Element>
+constexpr RepeatedField<Element>::RepeatedField(
+    internal::InternalMetadataOffset offset)
+    : soo_rep_(offset.TranslateForMember<offsetof(RepeatedField, soo_rep_)>()) {
+  StaticValidityCheck();
+#ifdef __cpp_lib_is_constant_evaluated
+  if (!std::is_constant_evaluated()) {
+    AnnotateSize(kSooCapacityElements, 0);
+  }
+#endif  // __cpp_lib_is_constant_evaluated
+}
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(
+    internal::InternalMetadataOffset offset, const RepeatedField& rhs)
+    : RepeatedField(offset) {
+  StaticValidityCheck();
+  AnnotateSize(kSooCapacityElements, 0);
+  if (auto size = rhs.size()) {
+    bool is_soo = true;
+    if (size > kSooCapacityElements) {
+      Grow(SelfArena{}, is_soo, 0, size);
+      is_soo = false;
+    }
+    ExchangeCurrentSize(size);
+    UninitializedCopyN(rhs.elements(rhs.is_soo()), size,
+                       unsafe_elements(is_soo));
+  }
+}
+
+template <typename Element>
+template <typename Iter, typename>
+RepeatedField<Element>::RepeatedField(Iter begin, Iter end) {
+  StaticValidityCheck();
+  AnnotateSize(kSooCapacityElements, 0);
+  Add(begin, end);
+}
+
+template <typename Element>
+RepeatedField<Element>::~RepeatedField() {
+  StaticValidityCheck();
+  const bool is_soo = this->is_soo();
+
+#ifndef NDEBUG
+  auto* arena = GetArena();
+  // Try to trigger segfault / asan failure in non-opt builds if arena_
+  // lifetime has ended before the destructor.
+  if (arena) (void)arena->SpaceAllocated();
+#endif
+  const int size = this->size();
+  if (size > 0) {
+    Element* elem = unsafe_elements(is_soo);
+    Destroy(elem, elem + size);
+  }
+  AnnotateForRelease();
+  if (!is_soo) {
+    InternalDeallocate</*in_destructor=*/true>(SelfArena{});
+  }
+}
+
+template <typename Element>
+inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+    const RepeatedField& other) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  if (this != &other) CopyFrom(other);
+  return *this;
+}
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(
+    internal::InternalMetadataOffset offset, RepeatedField&& rhs)
+    : RepeatedField(offset) {
+  Arena* arena = GetArena();
+  if (internal::CanMoveWithInternalSwap(arena, rhs.GetArena())) {
+    InternalSwap(&rhs);
+  } else {
+    // We don't just call Swap(&rhs) here because it would perform 3 copies if
+    // rhs is on a different arena.
+    CopyFrom(rhs);
+  }
+}
+
+template <typename Element>
+inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+    RepeatedField&& other) noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // the two fields are on different arenas.
+  if (this != &other) {
+    if (internal::CanMoveWithInternalSwap(GetArena(), other.GetArena())) {
+      InternalSwap(&other);
+    } else {
+      CopyFrom(other);
+    }
+  }
+  return *this;
+}
+
+template <typename Element>
+inline bool RepeatedField<Element>::empty() const {
+  return size() == 0;
+}
+
+template <typename Element>
+inline int RepeatedField<Element>::size() const {
+  return soo_rep_.size();
+}
+
+template <typename Element>
+inline int RepeatedField<Element>::Capacity() const {
+  return Capacity(is_soo());
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::AddAlreadyReserved(Element value) {
+  const bool is_soo = this->is_soo();
+  const int old_size = size();
+  internal::RuntimeAssertInBounds(old_size, Capacity(is_soo));
+  void* p = elements(is_soo) + ExchangeCurrentSize(old_size + 1);
+  ::new (p) Element(std::move(value));
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::AddAlreadyReserved()
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  const bool is_soo = this->is_soo();
+  const int old_size = size();
+  internal::RuntimeAssertInBounds(old_size, Capacity(is_soo));
+  // new (p) <TrivialType> compiles into nothing: this is intentional as this
+  // function is documented to return uninitialized data for trivial types.
+  void* p = elements(is_soo) + ExchangeCurrentSize(old_size + 1);
+  return ::new (p) Element;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::AddNAlreadyReserved(int n)
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  internal::RuntimeAssertInBoundsGE(n, 0);
+  const bool is_soo = this->is_soo();
+  const int old_size = size();
+  [[maybe_unused]] const int capacity = Capacity(is_soo);
+
+  const int64_t new_size_64 = static_cast<int64_t>(old_size) + n;
+  internal::RuntimeAssertInBoundsLE(new_size_64, capacity);
+
+  Element* p = unsafe_elements(is_soo) + ExchangeCurrentSize(old_size + n);
+  for (Element *begin = p, *end = p + n; begin != end; ++begin) {
+    new (static_cast<void*>(begin)) Element;
+  }
+  return p;
+}
+
+template <typename Element>
+ABSL_DEPRECATE_AND_INLINE()
+inline void RepeatedField<Element>::Resize(int new_size, const Element& value) {
+  resize(new_size, value);
+}
+
+template <typename Element>
+template <typename Init>
+inline void RepeatedField<Element>::ResizeImpl(int new_size, Init init) {
+  ABSL_DCHECK_GE(new_size, 0);
+  bool is_soo = this->is_soo();
+  const int old_size = size();
+  if (new_size > old_size) {
+    if (new_size > Capacity(is_soo)) {
+      Grow(SelfArena{}, is_soo, old_size, new_size);
+      is_soo = false;
+    }
+    Element* elem = elements(is_soo);
+    Element* first = elem + ExchangeCurrentSize(new_size);
+    init(first, elem + new_size);
+  } else if (new_size < old_size) {
+    Element* elem = unsafe_elements(is_soo);
+    Destroy(elem + new_size, elem + old_size);
+    ExchangeCurrentSize(new_size);
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::resize(size_type new_size,
+                                           const Element& value) {
+  ResizeImpl(new_size, [&](auto* first, auto* last) {
+    std::uninitialized_fill(first, last, value);
+  });
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::resize(size_type new_size) {
+  ResizeImpl(new_size, [](auto* first, auto* last) {
+    std::uninitialized_value_construct(first, last);
+  });
+}
+
+template <typename Element>
+inline const Element& RepeatedField<Element>::Get(int index) const
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  internal::RuntimeAssertInBounds(index, size());
+  return elements(is_soo())[index];
+}
+
+template <typename Element>
+inline const Element& RepeatedField<Element>::at(int index) const
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  ABSL_CHECK_GE(index, 0);
+  ABSL_CHECK_LT(index, size());
+  return elements(is_soo())[index];
+}
+
+template <typename Element>
+inline Element& RepeatedField<Element>::at(int index)
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  ABSL_CHECK_GE(index, 0);
+  ABSL_CHECK_LT(index, size());
+  return elements(is_soo())[index];
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::Mutable(int index)
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  internal::RuntimeAssertInBounds(index, size());
+  return &elements(is_soo())[index];
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Set(int index, const Element& value) {
+  *Mutable(index) = value;
+}
+
+template <typename Element>
+template <typename ArenaProvider>
+inline void* RepeatedField<Element>::AddUninitializedWithArena(
+    ArenaProvider arena_provider) {
+  ABSL_DCHECK_EQ(ResolveArena(arena_provider), GetSerialArena());
+
+  bool is_soo = this->is_soo();
+  const int old_size = size();
+  if (ABSL_PREDICT_FALSE(old_size == Capacity(is_soo))) {
+    Grow(arena_provider, is_soo, old_size, old_size + 1);
+    is_soo = false;
+  }
+  return unsafe_elements(is_soo) + ExchangeCurrentSize(old_size + 1);
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Add(Element value) {
+  AddWithArena(SelfArena{}, std::move(value));
+}
+
+template <typename Element>
+template <typename ArenaProvider>
+inline void RepeatedField<Element>::InternalAddWithArena(
+    internal::InternalVisibility, ArenaProvider arena_provider, Element value) {
+  AddWithArena(arena_provider, std::move(value));
+}
+
+template <typename Element>
+template <typename ArenaProvider>
+inline auto RepeatedField<Element>::AddWithArena(ArenaProvider arena_provider,
+                                                 Element value) -> pointer {
+  ABSL_DCHECK_EQ(ResolveArena(arena_provider), GetSerialArena());
+
+  bool is_soo = this->is_soo();
+  const int old_size = size();
+  int capacity = Capacity(is_soo);
+  Element* elem = unsafe_elements(is_soo);
+  if (ABSL_PREDICT_FALSE(old_size == capacity)) {
+    Grow(arena_provider, is_soo, old_size, old_size + 1);
+    is_soo = false;
+    capacity = Capacity(is_soo);
+    elem = unsafe_elements(is_soo);
+  }
+  int new_size = old_size + 1;
+  void* p = elem + ExchangeCurrentSize(new_size);
+  auto* result = ::new (p) Element(std::move(value));
+
+  // The below helps the compiler optimize dense loops.
+  // Note: we can't call functions in PROTOBUF_ASSUME so use local variables.
+  [[maybe_unused]] const bool final_is_soo = this->is_soo();
+  PROTOBUF_ASSUME(is_soo == final_is_soo);
+  [[maybe_unused]] const int final_size = size();
+  PROTOBUF_ASSUME(new_size == final_size);
+  [[maybe_unused]] Element* const final_elements = unsafe_elements(is_soo);
+  PROTOBUF_ASSUME(elem == final_elements);
+  [[maybe_unused]] const int final_capacity = Capacity(is_soo);
+  PROTOBUF_ASSUME(capacity == final_capacity);
+
+  return result;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::Add() ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return AddWithArena(SelfArena{});
+}
+
+template <typename Element>
+template <typename ArenaProvider>
+inline Element* RepeatedField<Element>::InternalAddWithArena(
+    internal::InternalVisibility,
+    ArenaProvider arena_provider) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return AddWithArena(arena_provider);
+}
+
+template <typename Element>
+template <typename ArenaProvider>
+inline Element* RepeatedField<Element>::AddWithArena(
+    ArenaProvider arena_provider) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return ::new (AddUninitializedWithArena(arena_provider)) Element;
+}
+
+template <typename Element>
+template <typename ArenaProvider, typename Iter>
+inline void RepeatedField<Element>::AddForwardIterator(
+    ArenaProvider arena_provider, Iter begin, Iter end) {
+  ABSL_DCHECK_EQ(ResolveArena(arena_provider), GetSerialArena());
+
+  bool is_soo = this->is_soo();
+  const int old_size = size();
+  int capacity = Capacity(is_soo);
+  Element* elem = unsafe_elements(is_soo);
+  // Check for signed overflow.
+  const size_t distance = std::distance(begin, end);
+  ABSL_CHECK_LE(distance, static_cast<size_t>(std::numeric_limits<int>::max()))
+      << "Input too large";
+  // Check again for signed overflow.
+  const int delta = static_cast<int>(distance);
+  ABSL_CHECK_LE(old_size, std::numeric_limits<int>::max() - delta)
+      << "Input too large";
+  const int new_size = old_size + delta;
+  if (ABSL_PREDICT_FALSE(new_size > capacity)) {
+    Grow(arena_provider, is_soo, old_size, new_size);
+    is_soo = false;
+    elem = unsafe_elements(is_soo);
+    capacity = Capacity(is_soo);
+  }
+  UninitializedCopy(begin, end, elem + ExchangeCurrentSize(new_size));
+
+  // The below helps the compiler optimize dense loops.
+  // Note: we can't call functions in PROTOBUF_ASSUME so use local variables.
+  [[maybe_unused]] const bool final_is_soo = this->is_soo();
+  PROTOBUF_ASSUME(is_soo == final_is_soo);
+  [[maybe_unused]] const int final_size = size();
+  PROTOBUF_ASSUME(new_size == final_size);
+  [[maybe_unused]] Element* const final_elements = unsafe_elements(is_soo);
+  PROTOBUF_ASSUME(elem == final_elements);
+  [[maybe_unused]] const int final_capacity = Capacity(is_soo);
+  PROTOBUF_ASSUME(capacity == final_capacity);
+}
+
+template <typename Element>
+template <typename ArenaProvider, typename Iter>
+inline void RepeatedField<Element>::AddInputIterator(
+    ArenaProvider arena_provider, Iter begin, Iter end) {
+  ABSL_DCHECK_EQ(ResolveArena(arena_provider), GetSerialArena());
+
+  bool is_soo = this->is_soo();
+  int size = this->size();
+  int capacity = Capacity(is_soo);
+  Element* elem = unsafe_elements(is_soo);
+  Element* first = elem + size;
+  Element* last = elem + capacity;
+  AnnotateForRelease();
+
+  while (begin != end) {
+    if (ABSL_PREDICT_FALSE(first == last)) {
+      size = first - elem;
+      GrowNoAnnotate(arena_provider, is_soo, size, size + 1);
+      is_soo = false;
+      elem = unsafe_elements(is_soo);
+      capacity = Capacity(is_soo);
+      first = elem + size;
+      last = elem + capacity;
+    }
+    ::new (static_cast<void*>(first)) Element(*begin);
+    ++begin;
+    ++first;
+  }
+
+  const int new_size = first - elem;
+  soo_rep_.set_size(new_size);
+  AnnotateSize(capacity, new_size);
+}
+
+template <typename Element>
+template <typename Iter>
+inline void RepeatedField<Element>::Add(Iter begin, Iter end) {
+  AddWithArena(SelfArena{}, std::move(begin), std::move(end));
+}
+
+template <typename Element>
+template <typename ArenaProvider, typename Iter>
+inline void RepeatedField<Element>::AddWithArena(ArenaProvider arena_provider,
+                                                 Iter begin, Iter end) {
+  if (std::is_base_of<
+          std::forward_iterator_tag,
+          typename std::iterator_traits<Iter>::iterator_category>::value) {
+    AddForwardIterator(arena_provider, begin, end);
+  } else {
+    AddInputIterator(arena_provider, begin, end);
+  }
+}
+
+template <typename Element>
+template <typename... Args>
+typename RepeatedField<Element>::pointer
+RepeatedField<Element>::EmplaceWithArena(Arena* arena, Args&&... args) {
+  return ::new (AddUninitializedWithArena(arena))
+      Element(std::forward<Args>(args)...);
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::RemoveLast() {
+  const bool is_soo = this->is_soo();
+  const int old_size = size();
+  ABSL_DCHECK_GT(old_size, 0);
+  elements(is_soo)[old_size - 1].~Element();
+  ExchangeCurrentSize(old_size - 1);
+}
+
+template <typename Element>
+void RepeatedField<Element>::ExtractSubrange(int start, int num,
+                                             Element* elements) {
+  ABSL_DCHECK_GE(start, 0);
+  ABSL_DCHECK_GE(num, 0);
+  const bool is_soo = this->is_soo();
+  const int old_size = size();
+  ABSL_DCHECK_LE(start + num, old_size);
+  Element* elem = unsafe_elements(is_soo);
+
+  // Save the values of the removed elements if requested.
+  if (elements != nullptr) {
+    for (int i = 0; i < num; ++i) elements[i] = std::move(elem[i + start]);
+  }
+
+  // Slide remaining elements down to fill the gap.
+  if (num > 0) {
+    for (int i = start + num; i < old_size; ++i)
+      elem[i - num] = std::move(elem[i]);
+    Truncate(old_size - num);
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Clear() {
+  const bool is_soo = this->is_soo();
+  Element* elem = unsafe_elements(is_soo);
+  Destroy(elem, elem + size());
+  ExchangeCurrentSize(0);
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::MergeFrom(const RepeatedField& other) {
+  ABSL_DCHECK_NE(&other, this);
+  const bool other_is_soo = other.is_soo();
+  if (auto other_size = other.size()) {
+    const int old_size = size();
+    Reserve(old_size + other_size);
+    const bool is_soo = this->is_soo();
+    Element* dst =
+        elements(is_soo) + ExchangeCurrentSize(old_size + other_size);
+    UninitializedCopyN(other.elements(other_is_soo), other_size, dst);
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
+  if (&other == this) return;
+  Clear();
+  MergeFrom(other);
+}
+
+template <typename Element>
+template <typename Iter>
+inline void RepeatedField<Element>::Assign(Iter begin, Iter end) {
+  Clear();
+  Add(begin, end);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+    const_iterator position) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return erase(position, position + 1);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+    const_iterator first, const_iterator last) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  size_type first_offset = first - cbegin();
+  if (first != last) {
+    Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
+  }
+  return begin() + first_offset;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::mutable_data()
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return unsafe_elements(is_soo());
+}
+
+template <typename Element>
+inline const Element* RepeatedField<Element>::data() const
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return unsafe_elements(is_soo());
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::InternalSwap(
+    RepeatedField* PROTOBUF_RESTRICT other) {
+  ABSL_DCHECK(this != other);
+
+  // We need to unpoison during the swap in case we're in SOO mode.
+  AnnotateForRelease();
+  other->AnnotateForRelease();
+
+  soo_rep_.swap(other->soo_rep_);
+
+  AnnotateSize(Capacity(), size());
+  other->AnnotateSize(other->Capacity(), other->size());
+}
+
+template <typename Element>
+void RepeatedField<Element>::SwapFallbackWithTemp(
+    Arena* arena, RepeatedField& other, Arena* other_arena,
+    RepeatedField<Element>& temp) {
+  ABSL_DCHECK(this != &other);
+
+  temp.MergeFrom(*this);
+  CopyFrom(other);
+  other.UnsafeArenaSwap(&temp);
+}
+
+template <typename Element>
+void RepeatedField<Element>::Swap(RepeatedField* other) {
+  if (this == other) return;
+  Arena* arena = GetArena();
+  Arena* other_arena = other->GetArena();
+  if (internal::CanUseInternalSwap(arena, other_arena)) {
+    InternalSwap(other);
+  } else if (other_arena != nullptr) {
+    // We can't call the destructor of the temp container since it allocates
+    // memory from an arena, and the destructor of FieldWithArena expects to be
+    // called only when arena is nullptr.
+    absl::NoDestructor<internal::RepeatedFieldWithArena<Element>>
+        temp_container(other_arena);
+    auto& temp = temp_container->field();
+    SwapFallbackWithTemp(arena, *other, other_arena, temp);
+
+    // If the element type is not destructor-skippable, then we need to invoke
+    // the destructor of the temporary `RepeatedField`.
+    if constexpr (!Arena::is_destructor_skippable<RepeatedField>::value) {
+      temp.~RepeatedField();
+    }
+  } else {
+    RepeatedField<Element> temp;
+    SwapFallbackWithTemp(arena, *other, other_arena, temp);
+  }
+}
+
+template <typename Element>
+void RepeatedField<Element>::UnsafeArenaSwap(RepeatedField* other) {
+  if (this == other) return;
+  ABSL_DCHECK_EQ(GetArena(), other->GetArena());
+  InternalSwap(other);
+}
+
+template <typename Element>
+void RepeatedField<Element>::SwapElements(int index1, int index2) {
+  internal::RuntimeAssertInBounds(index1, size());
+  internal::RuntimeAssertInBounds(index2, size());
+  Element* elem = elements(is_soo());
+  using std::swap;  // enable ADL with fallback
+  swap(elem[index1], elem[index2]);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::begin()
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return iterator(unsafe_elements(is_soo()));
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return const_iterator(unsafe_elements(is_soo()));
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  return const_iterator(unsafe_elements(is_soo()));
+}
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::end()
+    ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  const bool is_soo = this->is_soo();
+  return iterator(unsafe_elements(is_soo) + size());
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  const bool is_soo = this->is_soo();
+  return const_iterator(unsafe_elements(is_soo) + size());
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  const bool is_soo = this->is_soo();
+  return const_iterator(unsafe_elements(is_soo) + size());
+}
+
+template <typename Element>
+inline size_t RepeatedField<Element>::SpaceUsedExcludingSelfLong() const {
+  const int capacity = Capacity();
+  return capacity > kSooCapacityElements
+             ? capacity * sizeof(Element) + kHeapRepHeaderSize
+             : 0;
+}
+
+// Like C++20's std::erase_if, for RepeatedField
+template <typename T, typename Pred>
+size_t erase_if(RepeatedField<T>& cont, Pred pred) {
+  // Intentionally decay `elem` to avoid exposing a reference to elements of the
+  // repeated field directly.
+  using DecayedElement = internal::DecayedRepeatedFieldElement<T>;
+  auto it =
+      std::remove_if(cont.begin(), cont.end(),
+                     [&pred](const DecayedElement elem) { return pred(elem); });
+  size_t removed = cont.end() - it;
+  cont.Truncate(cont.size() - removed);
+  return removed;
+}
+
+// Like C++20's std::erase, for RepeatedField
+template <typename T, typename U>
+size_t erase(RepeatedField<T>& cont, const U& value) {
+  return google::protobuf::erase_if(cont,
+                          [&](const auto& elem) { return elem == value; });
+}
+
+// These functions mimic their std counterpart, but potentially more efficient
+// for Protobuf containers.
+template <int&..., typename T, typename Compare>
+void sort(internal::RepeatedIterator<T> begin,
+          internal::RepeatedIterator<T> end, Compare cmp) {
+  // Intentionally decay `lhs` and `rhs` to avoid exposing a reference to
+  // elements of the repeated field directly.
+  using DecayedElement = internal::DecayedRepeatedFieldElement<T>;
+  std::sort(begin, end,
+            [&cmp](const DecayedElement lhs, const DecayedElement rhs) {
+              return cmp(lhs, rhs);
+            });
+}
+template <int&..., typename T>
+void sort(internal::RepeatedIterator<T> begin,
+          internal::RepeatedIterator<T> end) {
+  google::protobuf::sort(begin, end, std::less<>{});
+}
+template <int&..., typename T, typename Compare>
+void stable_sort(internal::RepeatedIterator<T> begin,
+                 internal::RepeatedIterator<T> end, Compare cmp) {
+  // Intentionally decay `lhs` and `rhs` to avoid exposing a reference to
+  // elements of the repeated field directly.
+  using DecayedElement = internal::DecayedRepeatedFieldElement<T>;
+  std::stable_sort(begin, end,
+                   [&cmp](const DecayedElement lhs, const DecayedElement rhs) {
+                     return cmp(lhs, rhs);
+                   });
+}
+template <int&..., typename T>
+void stable_sort(internal::RepeatedIterator<T> begin,
+                 internal::RepeatedIterator<T> end) {
+  google::protobuf::stable_sort(begin, end, std::less<>{});
+}
+
+// These functions mimic their absl counterpart, but they are more efficient for
+// Protobuf containers.
+template <int&..., typename T, typename Compare>
+void c_sort(RepeatedField<T>& cont, Compare cmp) {
+  google::protobuf::sort(cont.begin(), cont.end(), cmp);
+}
+template <int&..., typename T>
+void c_sort(RepeatedField<T>& cont) {
+  google::protobuf::c_sort(cont, std::less<>{});
+}
+template <int&..., typename T, typename Compare>
+void c_stable_sort(RepeatedField<T>& cont, Compare cmp) {
+  google::protobuf::stable_sort(cont.begin(), cont.end(), cmp);
+}
+template <int&..., typename T>
+void c_stable_sort(RepeatedField<T>& cont) {
+  google::protobuf::c_stable_sort(cont, std::less<>{});
+}
+
+namespace internal {
+// Returns the new size for a reserved field based on its 'capacity' and the
+// requested 'new_size'. The result is clamped to the closed interval:
+//   [internal::kMinRepeatedFieldAllocationSize,
+//    std::numeric_limits<int>::max()]
+// Requires: new_size > capacity
+template <typename T, int kHeapRepHeaderSize>
+inline int CalculateReserveSize(int capacity, int new_size) {
+  constexpr int lower_limit =
+      RepeatedFieldLowerClampLimit<T, kHeapRepHeaderSize>();
+  if (new_size < lower_limit) {
+    // Clamp to smallest allowed size.
+    return lower_limit;
+  }
+  constexpr int kMaxSizeBeforeClamp =
+      (std::numeric_limits<int>::max() - kHeapRepHeaderSize) / 2;
+  if (ABSL_PREDICT_FALSE(capacity > kMaxSizeBeforeClamp)) {
+    return std::numeric_limits<int>::max();
+  }
+  constexpr int kSooCapacityElements = SooCapacityElements<T>();
+  if (kSooCapacityElements > 0 && kSooCapacityElements < lower_limit) {
+    // In this case, we need to set capacity to 0 here to ensure power-of-two
+    // sized allocations.
+    if (capacity < lower_limit) capacity = 0;
+  } else {
+    ABSL_DCHECK(capacity == 0 || capacity >= lower_limit)
+        << capacity << " " << lower_limit;
+  }
+  // We want to double the number of bytes, not the number of elements, to try
+  // to stay within power-of-two allocations.
+  // The allocation has kHeapRepHeaderSize + sizeof(T) * capacity.
+  int doubled_size = 2 * capacity + kHeapRepHeaderSize / sizeof(T);
+  return std::max(doubled_size, new_size);
+}
+}  // namespace internal
+
+template <typename Element>
+inline void RepeatedField<Element>::Reserve(int new_size) {
+  ReserveWithArena(SelfArena{}, new_size);
+}
+
+template <typename Element>
+template <typename ArenaProvider>
+void RepeatedField<Element>::ReserveWithArena(ArenaProvider arena_provider,
+                                              int new_size) {
+  const bool was_soo = is_soo();
+  if (ABSL_PREDICT_FALSE(new_size > Capacity(was_soo))) {
+    Grow(arena_provider, was_soo, size(), new_size);
+  }
+}
+
+// Avoid inlining of Reserve(): new, copy, and delete[] lead to a significant
+// amount of code bloat.
+template <typename Element>
+template <typename ArenaProvider>
+PROTOBUF_NOINLINE void RepeatedField<Element>::GrowNoAnnotate(
+    ArenaProvider arena_provider, bool was_soo, int old_size, int new_size) {
+  ABSL_DCHECK_EQ(ResolveArena(arena_provider), GetSerialArena());
+  const int old_capacity = Capacity(was_soo);
+  ABSL_DCHECK_GT(new_size, old_capacity);
+  HeapRep* new_rep;
+
+  new_size = internal::CalculateReserveSize<Element, kHeapRepHeaderSize>(
+      old_capacity, new_size);
+
+  ABSL_DCHECK_LE(static_cast<size_t>(new_size),
+                 (std::numeric_limits<size_t>::max() - kHeapRepHeaderSize) /
+                     sizeof(Element))
+      << "Requested size is too large to fit into size_t.";
+  size_t bytes =
+      kHeapRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
+  internal::SerialArena* arena = ResolveArena(arena_provider);
+  if (arena == nullptr) {
+    ABSL_DCHECK_LE((bytes - kHeapRepHeaderSize) / sizeof(Element),
+                   static_cast<size_t>(std::numeric_limits<int>::max()))
+        << "Requested size is too large to fit element count into int.";
+    internal::SizedPtr res = internal::AllocateAtLeast(bytes);
+    size_t num_available =
+        std::min((res.n - kHeapRepHeaderSize) / sizeof(Element),
+                 static_cast<size_t>(std::numeric_limits<int>::max()));
+    new_size = static_cast<int>(num_available);
+    new_rep = new (res.p) HeapRep(new_size);
+  } else {
+    if constexpr (internal::ArenaAlignDefault::Ceil(sizeof(Element)) !=
+                  sizeof(Element)) {
+      // We need to manually align the allocation.
+      bytes = internal::ArenaAlignDefault::Ceil(bytes);
+    }
+    new_rep =
+        new (arena->AllocateAligned<internal::AllocationClient::kArray>(bytes))
+            HeapRep(new_size);
+  }
+
+  if (old_size > 0) {
+    Element* pnew = static_cast<Element*>(new_rep->elements());
+    Element* pold = elements(was_soo);
+    if constexpr (std::is_trivially_copyable<Element>::value ||
+                  absl::is_trivially_relocatable<Element>::value) {
+      memcpy(static_cast<void*>(pnew), pold, old_size * sizeof(Element));
+    } else {
+      for (Element* end = pnew + old_size; pnew != end; ++pnew, ++pold) {
+        ::new (static_cast<void*>(pnew)) Element(std::move(*pold));
+        pold->~Element();
+      }
+    }
+  }
+  if (!was_soo) InternalDeallocate(arena);
+
+  soo_rep_.set_non_soo(new_rep);
+}
+
+// Ideally we would be able to use:
+//   template <bool annotate_size = true>
+//   void Grow();
+// However, as explained in b/266411038#comment9, this causes issues
+// in shared libraries for Youtube (and possibly elsewhere).
+template <typename Element>
+template <typename ArenaProvider>
+PROTOBUF_NOINLINE void RepeatedField<Element>::Grow(
+    ArenaProvider arena_provider, bool was_soo, int old_size, int new_size) {
+  AnnotateForRelease();
+  GrowNoAnnotate(arena_provider, was_soo, old_size, new_size);
+  AnnotateSize(Capacity(), old_size);
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Truncate(int new_size) {
+  const int old_size = size();
+  ABSL_DCHECK_LE(new_size, old_size);
+  if (new_size < old_size) {
+    Element* elem = unsafe_elements(this->is_soo());
+    Destroy(elem + new_size, elem + old_size);
+    ExchangeCurrentSize(new_size);
+  }
+}
+
+template <>
+PROTOBUF_EXPORT size_t
+RepeatedField<absl::Cord>::SpaceUsedExcludingSelfLong() const;
+
+// -------------------------------------------------------------------
+
+// Iterators and helper functions that follow the spirit of the STL
+// std::back_insert_iterator and std::back_inserter but are tailor-made
+// for RepeatedField and RepeatedPtrField. Typical usage would be:
+//
+//   std::copy(some_sequence.begin(), some_sequence.end(),
+//             RepeatedFieldBackInserter(proto.mutable_sequence()));
+//
+// Ported by johannes from util/gtl/proto-array-iterators.h
+
+namespace internal {
+
+// STL-like iterator implementation for RepeatedField.  You should not
+// refer to this class directly; use RepeatedField<T>::iterator instead.
+//
+// Note: All of the iterator operators *must* be inlined to avoid performance
+// regressions.  This is caused by the extern template declarations below (which
+// are required because of the RepeatedField extern template declarations).  If
+// any of these functions aren't explicitly inlined (e.g. defined in the class),
+// the compiler isn't allowed to inline them.
+template <typename Element>
+class RepeatedIterator {
+ private:
+  using traits =
+      std::iterator_traits<typename std::remove_const<Element>::type*>;
+
+ public:
+  // Note: value_type is never cv-qualified.
+  using value_type = typename traits::value_type;
+  using difference_type = typename traits::difference_type;
+  using pointer = Element*;
+  using reference = Element&;
+  using iterator_category = typename traits::iterator_category;
+  using iterator_concept = typename IteratorConceptSupport<traits>::tag;
+
+  constexpr RepeatedIterator() noexcept : it_(nullptr) {}
+
+  // Allows "upcasting" from RepeatedIterator<T**> to
+  // RepeatedIterator<const T*const*>.
+  template <typename OtherElement,
+            typename std::enable_if<std::is_convertible<
+                OtherElement*, pointer>::value>::type* = nullptr>
+  constexpr RepeatedIterator(
+      const RepeatedIterator<OtherElement>& other) noexcept
+      : it_(other.it_) {}
+
+  // dereferenceable
+  PROTOBUF_FUTURE_ADD_NODISCARD constexpr reference operator*() const noexcept {
+    return *it_;
+  }
+  PROTOBUF_FUTURE_ADD_NODISCARD constexpr pointer operator->() const noexcept {
+    return it_;
+  }
+
+ private:
+  // Helper alias to hide the internal type.
+  using iterator = RepeatedIterator<Element>;
+
+ public:
+  // {inc,dec}rementable
+  iterator& operator++() noexcept {
+    ++it_;
+    return *this;
+  }
+  iterator operator++(int) noexcept { return iterator(it_++); }
+  iterator& operator--() noexcept {
+    --it_;
+    return *this;
+  }
+  iterator operator--(int) noexcept { return iterator(it_--); }
+
+  // equality_comparable
+  friend constexpr bool operator==(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ == y.it_;
+  }
+  friend constexpr bool operator!=(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ != y.it_;
+  }
+
+  // less_than_comparable
+  friend constexpr bool operator<(const iterator& x,
+                                  const iterator& y) noexcept {
+    return x.it_ < y.it_;
+  }
+  friend constexpr bool operator<=(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ <= y.it_;
+  }
+  friend constexpr bool operator>(const iterator& x,
+                                  const iterator& y) noexcept {
+    return x.it_ > y.it_;
+  }
+  friend constexpr bool operator>=(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ >= y.it_;
+  }
+
+  // addable, subtractable
+  iterator& operator+=(difference_type d) noexcept {
+    it_ += d;
+    return *this;
+  }
+  constexpr iterator operator+(difference_type d) const noexcept {
+    return iterator(it_ + d);
+  }
+  friend constexpr iterator operator+(const difference_type d,
+                                      iterator it) noexcept {
+    return it + d;
+  }
+
+  iterator& operator-=(difference_type d) noexcept {
+    it_ -= d;
+    return *this;
+  }
+  iterator constexpr operator-(difference_type d) const noexcept {
+    return iterator(it_ - d);
+  }
+
+  // indexable
+  PROTOBUF_FUTURE_ADD_NODISCARD constexpr reference operator[](
+      difference_type d) const noexcept {
+    return it_[d];
+  }
+
+  // random access iterator
+  friend constexpr difference_type operator-(iterator it1,
+                                             iterator it2) noexcept {
+    return it1.it_ - it2.it_;
+  }
+
+ private:
+  template <typename OtherElement>
+  friend class RepeatedIterator;
+
+  // Allow construction from RepeatedField.
+  friend class RepeatedField<value_type>;
+  explicit RepeatedIterator(pointer it) noexcept : it_(it) {}
+
+  // The internal iterator.
+  pointer it_;
+};
+
+// A back inserter for RepeatedField objects.
+template <typename T>
+class RepeatedFieldBackInsertIterator {
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = T;
+  using pointer = void;
+  using reference = void;
+  using difference_type = std::ptrdiff_t;
+
+  explicit RepeatedFieldBackInsertIterator(
+      RepeatedField<T>* const mutable_field)
+      : field_(mutable_field) {}
+  RepeatedFieldBackInsertIterator<T>& operator=(const T& value) {
+    field_->Add(value);
+    return *this;
+  }
+  RepeatedFieldBackInsertIterator<T>& operator*() { return *this; }
+  RepeatedFieldBackInsertIterator<T>& operator++() { return *this; }
+  RepeatedFieldBackInsertIterator<T>& operator++(int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedField<T>* field_;
+};
+
+}  // namespace internal
+
+// Provides a back insert iterator for RepeatedField instances,
+// similar to std::back_inserter().
+template <typename T>
+internal::RepeatedFieldBackInsertIterator<T> RepeatedFieldBackInserter(
+    RepeatedField<T>* const mutable_field) {
+  return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
+}
+
+namespace internal {
+template <typename T>
+inline void CheckIndexInBoundsOrAbort(const RepeatedField<T>& field,
+                                      int index) {
+  if (ABSL_PREDICT_FALSE(index < 0 || index >= field.size())) {
+    LogIndexOutOfBoundsAndAbort(index, field.size());
+  }
+}
+
+template <typename T>
+const T& CheckedGetOrAbort(const RepeatedField<T>& field, int index) {
+  CheckIndexInBoundsOrAbort(field, index);
+  return field.Get(index);
+}
+
+template <typename T>
+inline T* CheckedMutableOrAbort(RepeatedField<T>* field, int index) {
+  CheckIndexInBoundsOrAbort(*field, index);
+  return field->Mutable(index);
+}
+}  // namespace internal
+
+
+}  // namespace protobuf
+}  // namespace google
+
+#include "google/protobuf/port_undef.inc"
+
+#endif  // GOOGLE_PROTOBUF_REPEATED_FIELD_H__