re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/log/internal/proto.cc

@@ -12,6 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// All of the data that passes through this code is trusted because it flows
+// through a closed loop within the absl::LogMessage object. It is not a robust
+// protocol buffer encoder or decoder.
+//
+// Encoding: When `LOG(INFO) << "foo"` is called, the library uses the Encode*
+// functions to build a protocol buffer in a private, fixed-size internal buffer
+// (`LogMessageData::encoded_buf`).
+//
+// Decoding: During the same logging call, `LogMessage::Flush()` calls
+// `FinalizeEncodingAndFormat()`, which uses `ProtoField::DecodeFrom` to parse
+// that same internal buffer to generate the human-readable string for
+// text-based log sinks.
+
 #include "absl/log/internal/proto.h"
 
 #include <algorithm>

package/vendor/abseil-cpp/absl/log/internal/structured_proto.cc

@@ -16,11 +16,11 @@
 #include "absl/log/internal/structured_proto.h"
 
 #include <cstdint>
+#include <variant>
 
 #include "absl/base/config.h"
 #include "absl/log/internal/proto.h"
 #include "absl/types/span.h"
-#include "absl/types/variant.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -81,11 +81,11 @@ struct I32EncoderVisitor final {
 // Handles protobuf-encoding a type contained inside `StructuredProtoField`.
 struct EncoderVisitor final {
   bool operator()(StructuredProtoField::Varint varint) {
-    return absl::visit(VarintEncoderVisitor{field_number, buf}, varint);
+    return std::visit(VarintEncoderVisitor{field_number, buf}, varint);
   }
 
   bool operator()(StructuredProtoField::I64 i64) {
-    return absl::visit(I64EncoderVisitor{field_number, buf}, i64);
+    return std::visit(I64EncoderVisitor{field_number, buf}, i64);
   }
 
   bool operator()(StructuredProtoField::LengthDelimited length_delimited) {
@@ -95,7 +95,7 @@ struct EncoderVisitor final {
   }
 
   bool operator()(StructuredProtoField::I32 i32) {
-    return absl::visit(I32EncoderVisitor{field_number, buf}, i32);
+    return std::visit(I32EncoderVisitor{field_number, buf}, i32);
   }
 
   uint64_t field_number;
@@ -106,7 +106,7 @@ struct EncoderVisitor final {
 
 bool EncodeStructuredProtoField(StructuredProtoField field,
                                 absl::Span<char>& buf) {
-  return absl::visit(EncoderVisitor{field.field_number, buf}, field.value);
+  return std::visit(EncoderVisitor{field.field_number, buf}, field.value);
 }
 
 }  // namespace log_internal

package/vendor/abseil-cpp/absl/log/internal/structured_proto.h

@@ -21,6 +21,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <variant>
 
 #include "absl/base/config.h"
 #include "absl/log/internal/proto.h"
@@ -35,11 +36,11 @@ namespace log_internal {
 struct StructuredProtoField final {
   // Numeric type encoded with varint encoding:
   // https://protobuf.dev/programming-guides/encoding/#varints
-  using Varint = absl::variant<uint64_t, int64_t, uint32_t, int32_t, bool>;
+  using Varint = std::variant<uint64_t, int64_t, uint32_t, int32_t, bool>;
 
   // Fixed-length 64-bit integer encoding:
   // https://protobuf.dev/programming-guides/encoding/#non-varints
-  using I64 = absl::variant<uint64_t, int64_t, double>;
+  using I64 = std::variant<uint64_t, int64_t, double>;
 
   // Length-delimited record type (string, sub-message):
   // https://protobuf.dev/programming-guides/encoding/#length-types
@@ -47,11 +48,11 @@ struct StructuredProtoField final {
 
   // Fixed-length 32-bit integer encoding:
   // https://protobuf.dev/programming-guides/encoding/#non-varints
-  using I32 = absl::variant<uint32_t, int32_t, float>;
+  using I32 = std::variant<uint32_t, int32_t, float>;
 
   // Valid record type:
   // https://protobuf.dev/programming-guides/encoding/#structure
-  using Value = absl::variant<Varint, I64, LengthDelimited, I32>;
+  using Value = std::variant<Varint, I64, LengthDelimited, I32>;
 
   // Field number for the protobuf value.
   uint64_t field_number;
@@ -88,7 +89,7 @@ inline size_t BufferSizeForStructuredProtoField(StructuredProtoField field) {
     uint64_t field_number;
   };
 
-  return absl::visit(BufferSizeVisitor{field.field_number}, field.value);
+  return std::visit(BufferSizeVisitor{field.field_number}, field.value);
 }
 
 // Encodes `field` into `buf` using protobuf encoding.

package/vendor/abseil-cpp/absl/log/internal/structured_proto_test.cc

@@ -71,7 +71,7 @@ INSTANTIATE_TEST_SUITE_P(
             {
                 42,
                 StructuredProtoField::Value{
-                    absl::in_place_type<StructuredProtoField::Varint>,
+                    std::in_place_type<StructuredProtoField::Varint>,
                     int32_t{23},
                 },
             },
@@ -82,7 +82,7 @@ INSTANTIATE_TEST_SUITE_P(
             {
                 42,
                 StructuredProtoField::Value{
-                    absl::in_place_type<StructuredProtoField::I64>,
+                    std::in_place_type<StructuredProtoField::I64>,
                     int64_t{23},
                 },
             },
@@ -103,7 +103,7 @@ INSTANTIATE_TEST_SUITE_P(
             {
                 42,
                 StructuredProtoField::Value{
-                    absl::in_place_type<StructuredProtoField::I32>,
+                    std::in_place_type<StructuredProtoField::I32>,
                     int32_t{23},
                 },
             },

package/vendor/abseil-cpp/absl/log/internal/vlog_config.cc

@@ -20,6 +20,7 @@
 #include <atomic>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -38,7 +39,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/synchronization/mutex.h"
-#include "absl/types/optional.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -189,7 +189,7 @@ int AppendVModuleLocked(absl::string_view module_pattern, int log_level)
 // Allocates memory.
 int PrependVModuleLocked(absl::string_view module_pattern, int log_level)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex) {
-  absl::optional<int> old_log_level;
+  std::optional<int> old_log_level;
   for (const auto& info : get_vmodule_info()) {
     if (FNMatch(info.module_pattern, module_pattern)) {
       old_log_level = info.vlog_level;

package/vendor/abseil-cpp/absl/log/internal/vlog_config_benchmark.cc

@@ -45,7 +45,7 @@ class SyntheticBinary {
                            const size_t max_sites_per_tu,
                            const int num_shuffles) {
     per_tu_data_.reserve(num_tus);
-    auto sites = absl::make_unique<VLogSite *[]>(num_tus * max_sites_per_tu);
+    auto sites = std::make_unique<VLogSite*[]>(num_tus * max_sites_per_tu);
     for (size_t i = 0; i < num_tus; i++) {
       const std::string filename =
           absl::StrCat("directory-", i / 100, "/subdirectory-", i % 100 / 10,
@@ -55,7 +55,7 @@ class SyntheticBinary {
           absl::LogUniform<size_t>(bitgen_, 1, max_sites_per_tu),
           absl::LogUniform<size_t>(bitgen_, 0,
                                    max_extra_static_data_bytes_per_tu));
-      auto buf = absl::make_unique<char[]>(layout.AllocSize());
+      auto buf = std::make_unique<char[]>(layout.AllocSize());
       layout.PoisonPadding(buf.get());
       memcpy(layout.Pointer<0>(buf.get()), filename.c_str(),
              filename.size() + 1);
@@ -78,7 +78,7 @@ class SyntheticBinary {
                        std::memory_order_seq_cst);
     }
     // Now do some shufflin'.
-    auto new_sites = absl::make_unique<VLogSite *[]>(num_sites_);
+    auto new_sites = std::make_unique<VLogSite*[]>(num_sites_);
     for (int shuffle_num = 0; shuffle_num < num_shuffles; shuffle_num++) {
       // Each shuffle cuts the ring into three pieces and rearranges them.
       const size_t cut_a = absl::Uniform(bitgen_, size_t{0}, num_sites_);

package/vendor/abseil-cpp/absl/log/log_format_test.cc

@@ -19,6 +19,7 @@
 #include <iomanip>
 #include <ios>
 #include <limits>
+#include <optional>
 #include <ostream>
 #include <sstream>
 #include <string>
@@ -28,6 +29,7 @@
 #ifdef __ANDROID__
 #include <android/api-level.h>
 #endif
+
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/base/config.h"
@@ -39,7 +41,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
+#include "absl/types/source_location.h"
 
 namespace {
 using ::absl::log_internal::AsString;
@@ -290,6 +292,21 @@ TYPED_TEST(SignedIntLogFormatTest, BitfieldNegative) {
   LOG(INFO) << value.bits;
 }
 
+TEST(SourceLocationTest, Format) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  absl::SourceLocation loc = absl::SourceLocation::current();
+  std::string expected = absl::StrCat(__FILE__, ":", __LINE__ - 1);
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(expected)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(expected))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << loc;
+}
+
 // Ignore these test cases on GCC due to "is too small to hold all values ..."
 // warning.
 #if !defined(__GNUC__) || defined(__clang__)
@@ -2096,7 +2113,7 @@ size_t MaxLogFieldLengthNoPrefix() {
     }
 
    private:
-    absl::optional<size_t> size_;
+    std::optional<size_t> size_;
   } extractor_sink;
   LOG(INFO).NoPrefix().ToSinkOnly(&extractor_sink)
       << std::string(2 * absl::log_internal::kLogMessageBufferSize, 'x');

package/vendor/abseil-cpp/absl/log/log_modifier_methods_test.cc

@@ -28,6 +28,7 @@
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
+#include "absl/types/source_location.h"
 
 namespace {
 #if GTEST_HAS_DEATH_TEST
@@ -88,6 +89,23 @@ TEST(TailCallsModifiesTest, AtLocationFileLineLifetime) {
       << "hello world";
 }
 
+TEST(TailCallsModifiesTest, AtLocationSourceLocation) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  const int log_line = __LINE__ + 1;
+  constexpr absl::SourceLocation loc = absl::SourceLocation::current();
+  auto do_log = [loc] { LOG(INFO).AtLocation(loc) << "hello world"; };
+
+  EXPECT_CALL(test_sink,
+              Send(AllOf(SourceFilename(Eq(__FILE__)),
+                         SourceBasename(Eq("log_modifier_methods_test.cc")),
+                         SourceLine(Eq(log_line)))));
+
+  test_sink.StartCapturingLogs();
+  do_log();
+}
+
 TEST(TailCallsModifiesTest, NoPrefix) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
   EXPECT_CALL(test_sink, Send).Times(0);

package/vendor/abseil-cpp/absl/log/log_streamer.h

@@ -24,6 +24,7 @@
 
 #include <ios>
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <utility>
@@ -34,6 +35,7 @@
 #include "absl/strings/internal/ostringstream.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/source_location.h"
 #include "absl/utility/utility.h"
 
 namespace absl {
@@ -82,10 +84,14 @@ class LogStreamer final {
       : severity_(severity),
         line_(line),
         file_(file),
-        stream_(absl::in_place, &buf_) {
+        stream_(std::in_place, &buf_) {
     // To match `LOG`'s defaults:
     stream_->setf(std::ios_base::showbase | std::ios_base::boolalpha);
   }
+  explicit LogStreamer(
+      absl::LogSeverity severity,
+      absl::SourceLocation loc = absl::SourceLocation::current())
+      : LogStreamer(severity, loc.file_name(), static_cast<int>(loc.line())) {}
 
   // A moved-from `absl::LogStreamer` does not `LOG` when destroyed,
   // and a program that streams into one has undefined behavior.
@@ -131,7 +137,7 @@ class LogStreamer final {
   std::string buf_;
   // A disengaged `stream_` indicates a moved-from `LogStreamer` that should not
   // `LOG` upon destruction.
-  absl::optional<absl::strings_internal::OStringStream> stream_;
+  std::optional<absl::strings_internal::OStringStream> stream_;
 };
 
 // LogInfoStreamer()
@@ -175,6 +181,27 @@ inline LogStreamer LogDebugFatalStreamer(absl::string_view file, int line) {
   return absl::LogStreamer(absl::kLogDebugFatal, file, line);
 }
 
+inline LogStreamer LogInfoStreamer(
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return absl::LogStreamer(absl::LogSeverity::kInfo, loc);
+}
+inline LogStreamer LogWarningStreamer(
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return absl::LogStreamer(absl::LogSeverity::kWarning, loc);
+}
+inline LogStreamer LogErrorStreamer(
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return absl::LogStreamer(absl::LogSeverity::kError, loc);
+}
+inline LogStreamer LogFatalStreamer(
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return absl::LogStreamer(absl::LogSeverity::kFatal, loc);
+}
+inline LogStreamer LogDebugFatalStreamer(
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  return absl::LogStreamer(absl::kLogDebugFatal, loc);
+}
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 

package/vendor/abseil-cpp/absl/log/log_streamer_test.cc

@@ -30,6 +30,7 @@
 #include "absl/log/log.h"
 #include "absl/log/scoped_mock_log.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/source_location.h"
 
 namespace {
 using ::absl::log_internal::DeathTestExpectedLogging;
@@ -448,4 +449,21 @@ TEST(LogStreamerTest, CorrectDefaultFlags) {
   LOG(INFO) << false << std::hex << 0xdeadbeef;
 }
 
+TEST(LogStreamerTest, AtSourceLocation) {
+  const int log_line = __LINE__ + 2;
+  auto do_log = [] {
+    WriteToStream("foo", &absl::LogInfoStreamer().stream());  //
+  };
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  EXPECT_CALL(test_sink,
+              Send(AllOf(SourceFilename(
+                             Eq(absl::SourceLocation::current().file_name())),
+                         SourceLine(Eq(log_line)))));
+
+  test_sink.StartCapturingLogs();
+  do_log();
+}
+
 }  // namespace

package/vendor/abseil-cpp/absl/log/scoped_mock_log_test.cc

@@ -261,7 +261,7 @@ TEST(ScopedMockLogTest, NoSequenceWithMultipleThreads) {
 
 TEST(ScopedMockLogTsanTest,
      ScopedMockLogCanBeDeletedWhenAnotherThreadIsLogging) {
-  auto log = absl::make_unique<absl::ScopedMockLog>();
+  auto log = std::make_unique<absl::ScopedMockLog>();
   EXPECT_CALL(*log, Log(absl::LogSeverity::kInfo, __FILE__, "Thread log"))
       .Times(AnyNumber());
 

package/vendor/abseil-cpp/absl/log/vlog_is_on.h

@@ -60,8 +60,6 @@
 
 #include "absl/log/absl_vlog_is_on.h"  // IWYU pragma: export
 
-// IWYU pragma: private, include "absl/log/log.h"
-
 // Each VLOG_IS_ON call site gets its own VLogSite that registers with the
 // global linked list of sites to asynchronously update its verbosity level on
 // changes to --v or --vmodule. The verbosity can also be set by manually

package/vendor/abseil-cpp/absl/log/vlog_is_on_test.cc

@@ -14,6 +14,8 @@
 
 #include "absl/log/vlog_is_on.h"
 
+#include <optional>
+
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/base/log_severity.h"
@@ -22,25 +24,24 @@
 #include "absl/log/globals.h"
 #include "absl/log/log.h"
 #include "absl/log/scoped_mock_log.h"
-#include "absl/types/optional.h"
 
 namespace {
 
 using ::testing::_;
 
-absl::optional<int> MaxLogVerbosity() {
+std::optional<int> MaxLogVerbosity() {
 #ifdef ABSL_MAX_VLOG_VERBOSITY
   return ABSL_MAX_VLOG_VERBOSITY;
 #else
-  return absl::nullopt;
+  return std::nullopt;
 #endif
 }
 
-absl::optional<int> MinLogLevel() {
+std::optional<int> MinLogLevel() {
 #ifdef ABSL_MIN_LOG_LEVEL
   return static_cast<int>(ABSL_MIN_LOG_LEVEL);
 #else
-  return absl::nullopt;
+  return std::nullopt;
 #endif
 }
 

package/vendor/abseil-cpp/absl/memory/memory.h

@@ -58,7 +58,7 @@ ABSL_NAMESPACE_BEGIN
 //   std::unique_ptr<X> x(NewX(1, 2));
 //
 // While `absl::WrapUnique` is useful for capturing the output of a raw
-// pointer factory, prefer 'absl::make_unique<T>(args...)' over
+// pointer factory, prefer 'std::make_unique<T>(args...)' over
 // 'absl::WrapUnique(new T(args...))'.
 //
 //   auto x = WrapUnique(new X(1, 2));  // works, but nonideal.
@@ -96,6 +96,53 @@ std::unique_ptr<T> WrapUnique(T* ptr) {
 // should use `std::make_unique`.
 using std::make_unique;
 
+namespace memory_internal {
+
+// Traits to select proper overload and return type for
+// `absl::make_unique_for_overwrite<>`.
+template <typename T>
+struct MakeUniqueResult {
+  using scalar = std::unique_ptr<T>;
+};
+template <typename T>
+struct MakeUniqueResult<T[]> {
+  using array = std::unique_ptr<T[]>;
+};
+template <typename T, size_t N>
+struct MakeUniqueResult<T[N]> {
+  using invalid = void;
+};
+
+}  // namespace memory_internal
+
+// These are make_unique_for_overwrite variants modeled after
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1973r1.pdf
+// Unlike std::make_unique, values are default initialized rather than value
+// initialized.
+//
+// `absl::make_unique_for_overwrite` overload for non-array types.
+template <typename T>
+typename memory_internal::MakeUniqueResult<T>::scalar
+make_unique_for_overwrite() {
+  return std::unique_ptr<T>(new T);
+}
+
+// `absl::make_unique_for_overwrite` overload for an array T[] of unknown
+// bounds. The array allocation needs to use the `new T[size]` form and cannot
+// take element constructor arguments. The `std::unique_ptr` will manage
+// destructing these array elements.
+template <typename T>
+typename memory_internal::MakeUniqueResult<T>::array make_unique_for_overwrite(
+    size_t n) {
+  return std::unique_ptr<T>(new typename std::remove_extent_t<T>[n]);
+}
+
+// `absl::make_unique_for_overwrite` overload for an array T[N] of known bounds.
+// This construction will be rejected.
+template <typename T, typename... Args>
+typename memory_internal::MakeUniqueResult<T>::invalid
+make_unique_for_overwrite(Args&&... /* args */) = delete;
+
 // -----------------------------------------------------------------------------
 // Function Template: RawPtr()
 // -----------------------------------------------------------------------------
@@ -120,7 +167,7 @@ inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; }
 //
 // Example:
 //
-//     auto up = absl::make_unique<int>(10);
+//     auto up = std::make_unique<int>(10);
 //     auto sp = absl::ShareUniquePtr(std::move(up));  // shared_ptr<int>
 //     CHECK_EQ(*sp, 10);
 //     CHECK(up == nullptr);
@@ -166,7 +213,8 @@ std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr) {
 // `std::pointer_traits` for platforms that had not yet provided it. Those
 // platforms are no longer supported. New code should simply use
 // `std::pointer_traits`.
-using std::pointer_traits;
+template <typename Ptr>
+using pointer_traits ABSL_DEPRECATE_AND_INLINE() = std::pointer_traits<Ptr>;
 
 // -----------------------------------------------------------------------------
 // Class Template: allocator_traits
@@ -176,7 +224,9 @@ using std::pointer_traits;
 // `std::allocator_traits` for platforms that had not yet provided it. Those
 // platforms are no longer supported. New code should simply use
 // `std::allocator_traits`.
-using std::allocator_traits;
+template <typename Alloc>
+using allocator_traits ABSL_DEPRECATE_AND_INLINE() =
+    std::allocator_traits<Alloc>;
 
 namespace memory_internal {
 
@@ -188,7 +238,7 @@ struct ExtractOr {
 };
 
 template <template <typename> class Extract, typename Obj, typename Default>
-struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>> {
+struct ExtractOr<Extract, Obj, Default, std::void_t<Extract<Obj>>> {
   using type = Extract<Obj>;
 };
 

package/vendor/abseil-cpp/absl/memory/memory_test.cc

@@ -64,6 +64,23 @@ TEST(WrapUniqueTest, WrapUnique) {
   EXPECT_EQ(0, DestructorVerifier::instance_count());
 }
 
+TEST(MakeUniqueForOverwriteTest, Basic) {
+  std::unique_ptr<int> p = absl::make_unique_for_overwrite<int>();
+  p = absl::make_unique_for_overwrite<int>();
+}
+
+// The initialization tests needs to suppress dead-store elimination, otherwise
+// memset is optimized away, and lifetime is assumed begin after new, triggering
+// uninitalized variable warnings. Various tricks to prevent memset from being
+// optimized away still result in uninitialized variable warnings.  Once we move
+// to a C++20 floor we can delegate to std::make_unique_for_overwrite and avoid
+// testing absl::make_unique_for_overwrite.
+// https://github.com/gcc-mirror/gcc/blob/be1da01067c898a3e3979bfb1edd05f115ab2e3e/libstdc%2B%2B-v3/testsuite/20_util/unique_ptr/creation/for_overwrite.cc#L1
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC push_options
+#pragma GCC optimize("O0")
+#endif
+
 // InitializationVerifier fills in a pattern when allocated so we can
 // distinguish between its default and value initialized states (without
 // accessing truly uninitialized memory).
@@ -87,6 +104,32 @@ struct InitializationVerifier {
   int b;
 };
 
+TEST(Initialization, MakeUniqueForOverwrite) {
+  auto p = absl::make_unique_for_overwrite<InitializationVerifier>();
+
+  int pattern;
+  memset(&pattern, InitializationVerifier::kDefaultScalar, sizeof(pattern));
+
+  EXPECT_EQ(pattern, p->a);
+  EXPECT_EQ(pattern, p->b);
+}
+
+TEST(Initialization, MakeUniqueForOverwriteArray) {
+  auto p = absl::make_unique_for_overwrite<InitializationVerifier[]>(2);
+
+  int pattern;
+  memset(&pattern, InitializationVerifier::kDefaultArray, sizeof(pattern));
+
+  EXPECT_EQ(pattern, p[0].a);
+  EXPECT_EQ(pattern, p[0].b);
+  EXPECT_EQ(pattern, p[1].a);
+  EXPECT_EQ(pattern, p[1].b);
+}
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC pop_options
+#endif
+
 struct ArrayWatch {
   void* operator new[](size_t n) {
     allocs().push_back(n);
@@ -99,6 +142,17 @@ struct ArrayWatch {
   }
 };
 
+TEST(MakeUniqueForOverwriteTest, Array) {
+  // Ensure state is clean before we start so that these tests
+  // are order-agnostic.
+  ArrayWatch::allocs().clear();
+
+  auto p = absl::make_unique_for_overwrite<ArrayWatch[]>(5);
+  static_assert(std::is_same<decltype(p), std::unique_ptr<ArrayWatch[]>>::value,
+                "unexpected return type");
+  EXPECT_THAT(ArrayWatch::allocs(), ElementsAre(5 * sizeof(ArrayWatch)));
+}
+
 TEST(RawPtrTest, RawPointer) {
   int i = 5;
   EXPECT_EQ(&i, absl::RawPtr(&i));
@@ -157,7 +211,7 @@ TEST(RawPtrTest, Zero) {
 }
 
 TEST(ShareUniquePtrTest, Share) {
-  auto up = absl::make_unique<int>();
+  auto up = std::make_unique<int>();
   int* rp = up.get();
   auto sp = absl::ShareUniquePtr(std::move(up));
   EXPECT_EQ(sp.get(), rp);

package/vendor/abseil-cpp/absl/meta/BUILD.bazel

@@ -42,6 +42,7 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
         "//absl:__subpackages__",
+        "//absl:friends",
     ],
     deps = [
         "//absl/base:config",
@@ -67,6 +68,7 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     visibility = [
         "//absl:__subpackages__",
+        "//absl:friends",
     ],
     deps = [
         "//absl/base:config",

package/vendor/abseil-cpp/absl/meta/internal/requires.h

@@ -52,7 +52,7 @@ namespace meta_internal {
 // code like the following is _not_ valid in C++17:
 //
 //  template <typename T,
-//            typename = std::enable_if_t<gtl::Requires<T>(
+//            typename = std::enable_if_t<Requires<T>(
 //              [] (auto&& v) -> decltype(<expr>) {})>>
 //
 template <typename... T, typename F>