grpc 1.84.0 → 1.85.0.pre1

data/third_party/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

data/third_party/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.

data/third_party/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,20 +39,31 @@
 #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
 namespace log_internal {
 
 namespace {
-bool ModuleIsPath(absl::string_view module_pattern) {
+
 #ifdef _WIN32
-  return module_pattern.find_first_of("/\\") != module_pattern.npos;
+constexpr char kPathSeparators[] = "/\\";
 #else
-  return module_pattern.find('/') != module_pattern.npos;
+constexpr char kPathSeparators[] = "/";
 #endif
+
+bool ModuleIsPath(absl::string_view module_pattern) {
+  return module_pattern.find_first_of(kPathSeparators) != module_pattern.npos;
+}
+
+absl::string_view Basename(absl::string_view file) {
+  auto sep = file.find_last_of(kPathSeparators);
+  if (sep != file.npos) {
+    file.remove_prefix(sep + 1);
+  }
+  return file;
 }
+
 }  // namespace
 
 bool VLogSite::SlowIsEnabled(int stale_v, int level) {
@@ -90,16 +102,16 @@ struct VModuleInfo final {
 // To avoid problems with the heap checker which calls into `VLOG`, `mutex` must
 // be a `SpinLock` that prevents fiber scheduling instead of a `Mutex`.
 ABSL_CONST_INIT absl::base_internal::SpinLock mutex(
-    absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY);
+    absl::base_internal::SCHEDULE_KERNEL_ONLY);
 
 // `GetUpdateSitesMutex()` serializes updates to all of the sites (i.e. those in
 // `site_list_head`) themselves.
-absl::Mutex* GetUpdateSitesMutex() {
+absl::Mutex& GetUpdateSitesMutex() {
   // Chromium requires no global destructors, so we can't use the
   // absl::kConstInit idiom since absl::Mutex as a non-trivial destructor.
   static absl::NoDestructor<absl::Mutex> update_sites_mutex ABSL_ACQUIRED_AFTER(
       mutex);
-  return update_sites_mutex.get();
+  return *update_sites_mutex;
 }
 
 ABSL_CONST_INIT int global_v ABSL_GUARDED_BY(mutex) = 0;
@@ -129,21 +141,9 @@ int VLogLevel(absl::string_view file, const std::vector<VModuleInfo>* infos,
   // parsing flags).  We can't allocate in `VLOG`, so we treat null as empty
   // here and press on.
   if (!infos || infos->empty()) return current_global_v;
-  // Get basename for file
-  absl::string_view basename = file;
-  {
-    const size_t sep = basename.rfind('/');
-    if (sep != basename.npos) {
-      basename.remove_prefix(sep + 1);
-#ifdef _WIN32
-    } else {
-      const size_t sep = basename.rfind('\\');
-      if (sep != basename.npos) basename.remove_prefix(sep + 1);
-#endif
-    }
-  }
 
-  absl::string_view stem = file, stem_basename = basename;
+  absl::string_view stem = file;
+  absl::string_view stem_basename = Basename(stem);
   {
     const size_t sep = stem_basename.find('.');
     if (sep != stem_basename.npos) {
@@ -159,10 +159,10 @@ int VLogLevel(absl::string_view file, const std::vector<VModuleInfo>* infos,
       // If there are any slashes in the pattern, try to match the full
       // name.
       if (FNMatch(info.module_pattern, stem)) {
-        return info.vlog_level == kUseFlag ? current_global_v : info.vlog_level;
+        return info.vlog_level;
       }
     } else if (FNMatch(info.module_pattern, stem_basename)) {
-      return info.vlog_level == kUseFlag ? current_global_v : info.vlog_level;
+      return info.vlog_level;
     }
   }
 
@@ -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;
@@ -222,7 +222,7 @@ int PrependVModuleLocked(absl::string_view module_pattern, int log_level)
 }  // namespace
 
 int VLogLevel(absl::string_view file) ABSL_LOCKS_EXCLUDED(mutex) {
-  absl::base_internal::SpinLockHolder l(&mutex);
+  absl::base_internal::SpinLockHolder l(mutex);
   return VLogLevel(file, vmodule_info, global_v);
 }
 
@@ -267,7 +267,7 @@ void UpdateVLogSites() ABSL_UNLOCK_FUNCTION(mutex)
   // have to wait on all updates in order to acquire `mutex` and initialize
   // themselves.
   absl::MutexLock ul(GetUpdateSitesMutex());
-  mutex.Unlock();
+  mutex.unlock();
   VLogSite* n = site_list_head.load(std::memory_order_seq_cst);
   // Because sites are added to the list in the order they are executed, there
   // tend to be clusters of entries with the same file.
@@ -299,7 +299,7 @@ void UpdateVModule(absl::string_view vmodule)
     if (!absl::SimpleAtoi(glob_level.substr(eq + 1), &level)) continue;
     glob_levels.emplace_back(glob, level);
   }
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   get_vmodule_info().clear();
   for (const auto& it : glob_levels) {
     const absl::string_view glob = it.first;
@@ -311,10 +311,10 @@ void UpdateVModule(absl::string_view vmodule)
 
 int UpdateGlobalVLogLevel(int v)
     ABSL_LOCKS_EXCLUDED(mutex, GetUpdateSitesMutex()) {
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   const int old_global_v = global_v;
   if (v == global_v) {
-    mutex.Unlock();
+    mutex.unlock();
     return old_global_v;
   }
   global_v = v;
@@ -324,7 +324,7 @@ int UpdateGlobalVLogLevel(int v)
 
 int PrependVModule(absl::string_view module_pattern, int log_level)
     ABSL_LOCKS_EXCLUDED(mutex, GetUpdateSitesMutex()) {
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   int old_v = PrependVModuleLocked(module_pattern, log_level);
   UpdateVLogSites();
   return old_v;

data/third_party/abseil-cpp/absl/log/internal/vlog_config.h

@@ -48,7 +48,6 @@ class VLogSite;
 
 int RegisterAndInitialize(VLogSite* absl_nonnull v);
 void UpdateVLogSites();
-constexpr int kUseFlag = (std::numeric_limits<int16_t>::min)();
 
 // Represents a unique callsite for a `VLOG()` or `VLOG_IS_ON()` call.
 //

data/third_party/abseil-cpp/absl/log/log.h

@@ -247,11 +247,11 @@
 // However, simply testing whether verbose logging is enabled can be expensive.
 // If you don't intend to enable verbose logging in non-debug builds, consider
 // using `DVLOG` instead.
-#define VLOG(severity) ABSL_LOG_INTERNAL_VLOG_IMPL(severity)
+#define VLOG(verbose_level) ABSL_LOG_INTERNAL_VLOG_IMPL(verbose_level)
 
 // `DVLOG` behaves like `VLOG` in debug mode (i.e. `#ifndef NDEBUG`).
 // Otherwise, it compiles away and does nothing.
-#define DVLOG(severity) ABSL_LOG_INTERNAL_DVLOG_IMPL(severity)
+#define DVLOG(verbose_level) ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)
 
 // `LOG_IF` and friends add a second argument which specifies a condition.  If
 // the condition is false, nothing is logged.

data/third_party/abseil-cpp/absl/log/log_entry.cc

@@ -0,0 +1,263 @@
+// Copyright 2025 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/log/log_entry.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <iomanip>
+#include <ios>
+#include <ostream>
+
+#include "absl/base/config.h"
+#include "absl/log/internal/proto.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace {
+// message `logging.proto.Event`
+enum EventTag : uint8_t {
+  kFileName = 2,
+  kFileLine = 3,
+  kTimeNsecs = 4,
+  kSeverity = 5,
+  kThreadId = 6,
+  kValue = 7,
+  kSequenceNumber = 9,
+  kThreadName = 10,
+};
+
+// message `logging.proto.Value`
+enum ValueTag : uint8_t {
+  kString = 1,
+  kStringLiteral = 6,
+};
+
+// enum `logging.proto.Severity`
+enum Severity : int {
+  FINEST = 300,
+  FINER = 400,
+  FINE = 500,
+  VERBOSE_0 = 600,
+  CONFIG = 700,
+  INFO = 800,
+  NOTICE = 850,
+  WARNING = 900,
+  ERROR = 950,
+  SEVERE = 1000,
+  FATAL = 1100,
+};
+
+void PrintEscapedRangeTo(const absl::string_view str,
+                         const absl::string_view substr, std::ostream* os) {
+  const absl::string_view head =
+      str.substr(0, static_cast<size_t>(substr.data() - str.data()));
+  const char old_fill = os->fill();
+  const auto old_flags = os->flags();
+  *os << std::right
+      << std::setw(static_cast<int>(absl::CHexEscape(head).size())) << "";
+  switch (substr.size()) {
+    case 0:
+      *os << "\\";
+      break;
+    case 1:
+      *os << "^";
+      break;
+    default:
+      *os << "[" << std::setw(static_cast<int>(absl::CHexEscape(substr).size()))
+          << std::setfill('-') << ")";
+      break;
+  }
+  os->fill(old_fill);
+  os->flags(old_flags);
+}
+}  // namespace
+void PrintTo(const LogEntry& entry, std::ostream* os) {
+  auto text_message_with_prefix_and_newline_and_nul = absl::string_view(
+      entry.text_message_with_prefix_and_newline_and_nul_.data(),
+      entry.text_message_with_prefix_and_newline_and_nul_.size());
+  *os << "LogEntry {\n"
+      << "  source_filename: \"" << absl::CHexEscape(entry.source_filename())
+      << "\"\n"
+      << "  source_basename: \"" << absl::CHexEscape(entry.source_basename())
+      << "\"\n"
+      << "  source_line: " << entry.source_line() << "\n"
+      << "  prefix: " << std::boolalpha << entry.prefix() << "\n"
+      << "  log_severity: " << entry.log_severity() << "\n"
+      << "  verbosity: " << entry.verbosity();
+  if (entry.verbosity() == absl::LogEntry::kNoVerbosityLevel) {
+    *os << " (kNoVerbosityLevel)";
+  }
+  *os << "\n"
+      << "  timestamp: " << entry.timestamp() << "\n"
+      << "  tid: " << entry.tid() << "\n"
+      << "  text_message_with_prefix_and_newline_and_nul_: \""
+      << absl::CHexEscape(text_message_with_prefix_and_newline_and_nul)
+      << "\"\n"
+      << "  text_message_with_prefix_and_newline:           ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message_with_prefix_and_newline(), os);
+  *os << "\n"
+      << "  text_message_with_prefix:                       ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message_with_prefix(), os);
+  *os << "\n"
+      << "  text_message_with_newline:                      ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message_with_newline(), os);
+  *os << "\n"
+      << "  text_message:                                   ";
+  PrintEscapedRangeTo(text_message_with_prefix_and_newline_and_nul,
+                      entry.text_message(), os);
+  *os << "\n"
+      << "  text_message_with_prefix_and_newline_c_str:     ";
+  PrintEscapedRangeTo(
+      text_message_with_prefix_and_newline_and_nul,
+      // NOLINTNEXTLINE(bugprone-string-constructor)
+      absl::string_view(entry.text_message_with_prefix_and_newline_c_str(), 0),
+      os);
+  *os << "\n"
+      << "  encoded_message (raw): \""
+      << absl::CHexEscape(entry.encoded_message()) << "\"\n"
+      << "  encoded_message {\n";
+  absl::Span<const char> event = entry.encoded_message();
+  log_internal::ProtoField field;
+  while (field.DecodeFrom(&event)) {
+    switch (field.tag()) {
+      case EventTag::kFileName:
+        *os << "    file_name: \"" << absl::CHexEscape(field.string_value())
+            << "\"\n";
+        break;
+      case EventTag::kFileLine:
+        *os << "    file_line: " << field.int32_value() << "\n";
+        break;
+      case EventTag::kTimeNsecs:
+        *os << "    time_nsecs: " << field.int64_value() << " ("
+            << absl::FromUnixNanos(field.int64_value()) << ")\n";
+        break;
+      case EventTag::kSeverity:
+        *os << "    severity: " << field.int32_value();
+        switch (field.int32_value()) {
+          case Severity::FINEST:
+            *os << " (FINEST)";
+            break;
+          case Severity::FINER:
+            *os << " (FINER)";
+            break;
+          case Severity::FINE:
+            *os << " (FINE)";
+            break;
+          case Severity::VERBOSE_0:
+            *os << " (VERBOSE_0)";
+            break;
+          case Severity::CONFIG:
+            *os << " (CONFIG)";
+            break;
+          case Severity::INFO:
+            *os << " (INFO)";
+            break;
+          case Severity::NOTICE:
+            *os << " (NOTICE)";
+            break;
+          case Severity::WARNING:
+            *os << " (WARNING)";
+            break;
+          case Severity::ERROR:
+            *os << " (ERROR)";
+            break;
+          case Severity::SEVERE:
+            *os << " (SEVERE)";
+            break;
+          case Severity::FATAL:
+            *os << " (FATAL)";
+            break;
+        }
+        *os << "\n";
+        break;
+      case EventTag::kThreadId:
+        *os << "    thread_id: " << field.int64_value() << "\n";
+        break;
+      case EventTag::kValue: {
+        *os << "    value {\n";
+        auto value = field.bytes_value();
+        while (field.DecodeFrom(&value)) {
+          switch (field.tag()) {
+            case ValueTag::kString:
+              *os << "      str: \"" << absl::CHexEscape(field.string_value())
+                  << "\"\n";
+              break;
+            case ValueTag::kStringLiteral:
+              *os << "      literal: \""
+                  << absl::CHexEscape(field.string_value()) << "\"\n";
+              break;
+            default:
+              *os << "      unknown field " << field.tag();
+              switch (field.type()) {
+                case log_internal::WireType::kVarint:
+                  *os << " (VARINT): " << std::hex << std::showbase
+                      << field.uint64_value() << std::dec << "\n";
+                  break;
+                case log_internal::WireType::k64Bit:
+                  *os << " (I64): " << std::hex << std::showbase
+                      << field.uint64_value() << std::dec << "\n";
+                  break;
+                case log_internal::WireType::kLengthDelimited:
+                  *os << " (LEN): \"" << absl::CHexEscape(field.string_value())
+                      << "\"\n";
+                  break;
+                case log_internal::WireType::k32Bit:
+                  *os << " (I32): " << std::hex << std::showbase
+                      << field.uint32_value() << std::dec << "\n";
+                  break;
+              }
+              break;
+          }
+        }
+        *os << "    }\n";
+        break;
+      }
+      default:
+        *os << "    unknown field " << field.tag();
+        switch (field.type()) {
+          case log_internal::WireType::kVarint:
+            *os << " (VARINT): " << std::hex << std::showbase
+                << field.uint64_value() << std::dec << "\n";
+            break;
+          case log_internal::WireType::k64Bit:
+            *os << " (I64): " << std::hex << std::showbase
+                << field.uint64_value() << std::dec << "\n";
+            break;
+          case log_internal::WireType::kLengthDelimited:
+            *os << " (LEN): \"" << absl::CHexEscape(field.string_value())
+                << "\"\n";
+            break;
+          case log_internal::WireType::k32Bit:
+            *os << " (I32): " << std::hex << std::showbase
+                << field.uint32_value() << std::dec << "\n";
+            break;
+        }
+        break;
+    }
+  }
+  *os << "  }\n"
+      << "  stacktrace: \"" << absl::CHexEscape(entry.stacktrace()) << "\"\n"
+      << "}";
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl

data/third_party/abseil-cpp/absl/log/log_entry.h

@@ -25,6 +25,7 @@
 #define ABSL_LOG_LOG_ENTRY_H_
 
 #include <cstddef>
+#include <ostream>
 #include <string>
 
 #include "absl/base/attributes.h"
@@ -213,6 +214,7 @@ class LogEntry final {
 
   friend class log_internal::LogEntryTestPeer;
   friend class log_internal::LogMessage;
+  friend void PrintTo(const absl::LogEntry& entry, std::ostream* os);
 };
 
 ABSL_NAMESPACE_END

data/third_party/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

data/third_party/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>;
 };