grpc 1.84.0 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/flags/internal/flag.cc

@@ -26,6 +26,7 @@
 #include <memory>
 #include <string>
 #include <typeinfo>
+#include <utility>
 #include <vector>
 
 #include "absl/base/attributes.h"
@@ -73,8 +74,8 @@ bool ShouldValidateFlagValue(FlagFastTypeId flag_type_id) {
 // need to acquire these locks themselves.
 class MutexRelock {
  public:
-  explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.Unlock(); }
-  ~MutexRelock() { mu_.Lock(); }
+  explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.unlock(); }
+  ~MutexRelock() { mu_.lock(); }
 
   MutexRelock(const MutexRelock&) = delete;
   MutexRelock& operator=(const MutexRelock&) = delete;
@@ -88,9 +89,9 @@ class MutexRelock {
 // we move the memory to the freelist where it lives indefinitely, so it can
 // still be safely accessed. This also prevents leak checkers from complaining
 // about the leaked memory that can no longer be accessed through any pointer.
-absl::Mutex* FreelistMutex() {
+absl::Mutex& FreelistMutex() {
   static absl::NoDestructor<absl::Mutex> mutex;
-  return mutex.get();
+  return *mutex;
 }
 ABSL_CONST_INIT std::vector<void*>* s_freelist ABSL_GUARDED_BY(FreelistMutex())
     ABSL_PT_GUARDED_BY(FreelistMutex()) = nullptr;
@@ -139,8 +140,8 @@ class FlagState : public flags_internal::FlagStateInterface {
   friend class FlagImpl;
 
   // Restores the flag to the saved state.
-  void Restore() const override {
-    if (!flag_impl_.RestoreState(*this)) return;
+  void Restore() && override {
+    if (!std::move(flag_impl_).RestoreState(*this)) return;
 
     ABSL_INTERNAL_LOG(INFO,
                       absl::StrCat("Restore saved value of ", flag_impl_.Name(),
@@ -248,12 +249,12 @@ void FlagImpl::Init() {
   seq_lock_.MarkInitialized();
 }
 
-absl::Mutex* FlagImpl::DataGuard() const {
+absl::Mutex& FlagImpl::DataGuard() const {
   absl::call_once(const_cast<FlagImpl*>(this)->init_control_, &FlagImpl::Init,
                   const_cast<FlagImpl*>(this));
 
   // data_guard_ is initialized inside Init.
-  return reinterpret_cast<absl::Mutex*>(&data_guard_);
+  return *reinterpret_cast<absl::Mutex*>(&data_guard_);
 }
 
 void FlagImpl::AssertValidType(FlagFastTypeId rhs_type_id,
@@ -375,7 +376,7 @@ std::string FlagImpl::DefaultValue() const {
 }
 
 std::string FlagImpl::CurrentValue() const {
-  auto* guard = DataGuard();  // Make sure flag initialized
+  auto& guard = DataGuard();  // Make sure flag initialized
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kValueAndInitBit:
     case FlagValueStorageKind::kOneWordAtomic: {
@@ -429,8 +430,8 @@ void FlagImpl::InvokeCallback() const {
   // and it also can be different by the time the callback invocation is
   // completed. Requires that *primary_lock be held in exclusive mode; it may be
   // released and reacquired by the implementation.
-  MutexRelock relock(*DataGuard());
-  absl::MutexLock lock(&callback_->guard);
+  MutexRelock relock(DataGuard());
+  absl::MutexLock lock(callback_->guard);
   cb();
 }
 
@@ -442,7 +443,7 @@ std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kValueAndInitBit:
     case FlagValueStorageKind::kOneWordAtomic: {
-      return absl::make_unique<FlagState>(
+      return std::make_unique<FlagState>(
           *this, OneWordValue().load(std::memory_order_acquire), modified,
           on_command_line, ModificationCount());
     }
@@ -453,11 +454,11 @@ std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
           seq_lock_.TryRead(cloned, AtomicBufferValue(), Sizeof(op_));
       assert(success);
       static_cast<void>(success);
-      return absl::make_unique<FlagState>(*this, cloned, modified,
-                                          on_command_line, ModificationCount());
+      return std::make_unique<FlagState>(*this, cloned, modified,
+                                         on_command_line, ModificationCount());
     }
     case FlagValueStorageKind::kHeapAllocated: {
-      return absl::make_unique<FlagState>(
+      return std::make_unique<FlagState>(
           *this,
           flags_internal::Clone(
               op_, PtrStorage().load(std::memory_order_acquire).Ptr()),
@@ -535,7 +536,7 @@ std::unique_ptr<void, DynValueDeleter> FlagImpl::TryParse(
 }
 
 void FlagImpl::Read(void* dst) const {
-  auto* guard = DataGuard();  // Make sure flag initialized
+  auto& guard = DataGuard();  // Make sure flag initialized
   switch (ValueStorageKind()) {
     case FlagValueStorageKind::kValueAndInitBit:
     case FlagValueStorageKind::kOneWordAtomic: {
@@ -567,14 +568,14 @@ void FlagImpl::Read(void* dst) const {
 int64_t FlagImpl::ReadOneWord() const {
   assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
          ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
-  auto* guard = DataGuard();  // Make sure flag initialized
+  auto& guard = DataGuard();  // Make sure flag initialized
   (void)guard;
   return OneWordValue().load(std::memory_order_acquire);
 }
 
 bool FlagImpl::ReadOneBool() const {
   assert(ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
-  auto* guard = DataGuard();  // Make sure flag initialized
+  auto& guard = DataGuard();  // Make sure flag initialized
   (void)guard;
   return absl::bit_cast<FlagValueAndInitBit<bool>>(
              OneWordValue().load(std::memory_order_acquire))

data/third_party/abseil-cpp/absl/flags/internal/flag.h

@@ -135,7 +135,7 @@ inline size_t Sizeof(FlagOpFn op) {
 }
 // Returns fast type id corresponding to the value type.
 inline FlagFastTypeId FastTypeId(FlagOpFn op) {
-  return reinterpret_cast<FlagFastTypeId>(
+  return absl::bit_cast<FlagFastTypeId>(
       op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr));
 }
 // Returns fast type id corresponding to the value type.
@@ -168,7 +168,7 @@ inline const std::type_info* GenRuntimeTypeId() {
 // Flag help auxiliary structs.
 
 // This is help argument for absl::Flag encapsulating the string literal pointer
-// or pointer to function generating it as well as enum descriminating two
+// or pointer to function generating it as well as enum discriminating two
 // cases.
 using HelpGenFunc = std::string (*)();
 
@@ -178,7 +178,7 @@ struct FixedCharArray {
 
   template <size_t... I>
   static constexpr FixedCharArray<N> FromLiteralString(
-      absl::string_view str, absl::index_sequence<I...>) {
+      absl::string_view str, std::index_sequence<I...>) {
     return (void)str, FixedCharArray<N>({{str[I]..., '\0'}});
   }
 };
@@ -186,7 +186,7 @@ struct FixedCharArray {
 template <typename Gen, size_t N = Gen::Value().size()>
 constexpr FixedCharArray<N + 1> HelpStringAsArray(int) {
   return FixedCharArray<N + 1>::FromLiteralString(
-      Gen::Value(), absl::make_index_sequence<N>{});
+      Gen::Value(), std::make_index_sequence<N>{});
 }
 
 template <typename Gen>
@@ -601,17 +601,17 @@ class FlagImpl final : public CommandLineFlag {
         data_guard_{} {}
 
   // Constant access methods
-  int64_t ReadOneWord() const ABSL_LOCKS_EXCLUDED(*DataGuard());
-  bool ReadOneBool() const ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void Read(void* dst) const override ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void Read(bool* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
+  int64_t ReadOneWord() const ABSL_LOCKS_EXCLUDED(DataGuard());
+  bool ReadOneBool() const ABSL_LOCKS_EXCLUDED(DataGuard());
+  void Read(void* dst) const override ABSL_LOCKS_EXCLUDED(DataGuard());
+  void Read(bool* value) const ABSL_LOCKS_EXCLUDED(DataGuard()) {
     *value = ReadOneBool();
   }
   template <typename T,
-            absl::enable_if_t<flags_internal::StorageKind<T>() ==
+            std::enable_if_t<flags_internal::StorageKind<T>() ==
                                   FlagValueStorageKind::kOneWordAtomic,
                               int> = 0>
-  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
+  void Read(T* value) const ABSL_LOCKS_EXCLUDED(DataGuard()) {
     int64_t v = ReadOneWord();
     std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
   }
@@ -619,17 +619,17 @@ class FlagImpl final : public CommandLineFlag {
             typename std::enable_if<flags_internal::StorageKind<T>() ==
                                         FlagValueStorageKind::kValueAndInitBit,
                                     int>::type = 0>
-  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
+  void Read(T* value) const ABSL_LOCKS_EXCLUDED(DataGuard()) {
     *value = absl::bit_cast<FlagValueAndInitBit<T>>(ReadOneWord()).value;
   }
 
   // Mutating access methods
-  void Write(const void* src) ABSL_LOCKS_EXCLUDED(*DataGuard());
+  void Write(const void* src) ABSL_LOCKS_EXCLUDED(DataGuard());
 
   // Interfaces to operate on callbacks.
   void SetCallback(const FlagCallbackFunc mutation_callback)
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+      ABSL_LOCKS_EXCLUDED(DataGuard());
+  void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard());
 
   // Used in read/write operations to validate source/target has correct type.
   // For example if flag is declared as absl::Flag<int> FLAGS_foo, a call to
@@ -646,11 +646,11 @@ class FlagImpl final : public CommandLineFlag {
   friend class FlagState;
 
   // Ensures that `data_guard_` is initialized and returns it.
-  absl::Mutex* DataGuard() const
+  absl::Mutex& DataGuard() const
       ABSL_LOCK_RETURNED(reinterpret_cast<absl::Mutex*>(data_guard_));
   // Returns heap allocated value of type T initialized with default value.
   std::unique_ptr<void, DynValueDeleter> MakeInitValue() const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard());
   // Flag initialization called via absl::call_once.
   void Init();
 
@@ -676,16 +676,15 @@ class FlagImpl final : public CommandLineFlag {
   // returns new value. Otherwise returns nullptr.
   std::unique_ptr<void, DynValueDeleter> TryParse(absl::string_view value,
                                                   std::string& err) const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard());
   // Stores the flag value based on the pointer to the source.
   void StoreValue(const void* src, ValueSource source)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard());
 
   // Copy the flag data, protected by `seq_lock_` into `dst`.
   //
   // REQUIRES: ValueStorageKind() == kSequenceLocked.
-  void ReadSequenceLockedData(void* dst) const
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
+  void ReadSequenceLockedData(void* dst) const ABSL_LOCKS_EXCLUDED(DataGuard());
 
   FlagHelpKind HelpSourceKind() const {
     return static_cast<FlagHelpKind>(help_source_kind_);
@@ -694,7 +693,7 @@ class FlagImpl final : public CommandLineFlag {
     return static_cast<FlagValueStorageKind>(value_storage_kind_);
   }
   FlagDefaultKind DefaultKind() const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()) {
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard()) {
     return static_cast<FlagDefaultKind>(def_kind_);
   }
 
@@ -705,30 +704,30 @@ class FlagImpl final : public CommandLineFlag {
   std::string Help() const override;
   FlagFastTypeId TypeId() const override;
   bool IsSpecifiedOnCommandLine() const override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-  std::string DefaultValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
-  std::string CurrentValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
+      ABSL_LOCKS_EXCLUDED(DataGuard());
+  std::string DefaultValue() const override ABSL_LOCKS_EXCLUDED(DataGuard());
+  std::string CurrentValue() const override ABSL_LOCKS_EXCLUDED(DataGuard());
   bool ValidateInputValue(absl::string_view value) const override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
+      ABSL_LOCKS_EXCLUDED(DataGuard());
   void CheckDefaultValueParsingRoundtrip() const override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
+      ABSL_LOCKS_EXCLUDED(DataGuard());
 
-  int64_t ModificationCount() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+  int64_t ModificationCount() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(DataGuard());
 
   // Interfaces to save and restore flags to/from persistent state.
   // Returns current flag state or nullptr if flag does not support
   // saving and restoring a state.
   std::unique_ptr<FlagStateInterface> SaveState() override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
+      ABSL_LOCKS_EXCLUDED(DataGuard());
 
   // Restores the flag state to the supplied state object. If there is
   // nothing to restore returns false. Otherwise returns true.
   bool RestoreState(const FlagState& flag_state)
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
+      ABSL_LOCKS_EXCLUDED(DataGuard());
 
   bool ParseFrom(absl::string_view value, FlagSettingMode set_mode,
                  ValueSource source, std::string& error) override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
+      ABSL_LOCKS_EXCLUDED(DataGuard());
 
   // Immutable flag's state.
 
@@ -758,9 +757,9 @@ class FlagImpl final : public CommandLineFlag {
   // locks.
   uint8_t def_kind_ : 2;
   // Has this flag's value been modified?
-  bool modified_ : 1 ABSL_GUARDED_BY(*DataGuard());
+  bool modified_ : 1 ABSL_GUARDED_BY(DataGuard());
   // Has this flag been specified on command line.
-  bool on_command_line_ : 1 ABSL_GUARDED_BY(*DataGuard());
+  bool on_command_line_ : 1 ABSL_GUARDED_BY(DataGuard());
 
   // Unique tag for absl::call_once call to initialize this flag.
   absl::once_flag init_control_;
@@ -769,7 +768,7 @@ class FlagImpl final : public CommandLineFlag {
   flags_internal::SequenceLock seq_lock_;
 
   // Optional flag's callback and absl::Mutex to guard the invocations.
-  FlagCallback* callback_ ABSL_GUARDED_BY(*DataGuard());
+  FlagCallback* callback_ ABSL_GUARDED_BY(DataGuard());
   // Either a pointer to the function generating the default value based on the
   // value specified in ABSL_FLAG or pointer to the dynamically set default
   // value via SetCommandLineOptionWithMode. def_kind_ is used to distinguish
@@ -902,7 +901,7 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
     case FlagOp::kSizeof:
       return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
     case FlagOp::kFastTypeId:
-      return const_cast<void*>(absl::FastTypeId<T>());
+      return absl::bit_cast<void*>(absl::FastTypeId<T>());
     case FlagOp::kRuntimeTypeId:
       return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
     case FlagOp::kParse: {

data/third_party/abseil-cpp/absl/flags/internal/program_name.cc

@@ -29,9 +29,9 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace flags_internal {
 
-static absl::Mutex* ProgramNameMutex() {
+static absl::Mutex& ProgramNameMutex() {
   static absl::NoDestructor<absl::Mutex> mutex;
-  return mutex.get();
+  return *mutex;
 }
 ABSL_CONST_INIT static std::string* program_name ABSL_GUARDED_BY(
     ProgramNameMutex()) ABSL_PT_GUARDED_BY(ProgramNameMutex()) = nullptr;

data/third_party/abseil-cpp/absl/flags/marshalling.cc

@@ -45,22 +45,7 @@ namespace flags_internal {
 // AbslParseFlag specializations for boolean type.
 
 bool AbslParseFlag(absl::string_view text, bool* dst, std::string*) {
-  const char* kTrue[] = {"1", "t", "true", "y", "yes"};
-  const char* kFalse[] = {"0", "f", "false", "n", "no"};
-  static_assert(sizeof(kTrue) == sizeof(kFalse), "true_false_equal");
-
-  text = absl::StripAsciiWhitespace(text);
-
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(kTrue); ++i) {
-    if (absl::EqualsIgnoreCase(text, kTrue[i])) {
-      *dst = true;
-      return true;
-    } else if (absl::EqualsIgnoreCase(text, kFalse[i])) {
-      *dst = false;
-      return true;
-    }
-  }
-  return false;  // didn't match a legal input
+  return SimpleAtob(absl::StripAsciiWhitespace(text), dst);
 }
 
 // --------------------------------------------------------------------

data/third_party/abseil-cpp/absl/flags/marshalling.h

@@ -199,15 +199,12 @@
 #ifndef ABSL_FLAGS_MARSHALLING_H_
 #define ABSL_FLAGS_MARSHALLING_H_
 
-#include "absl/base/config.h"
-#include "absl/numeric/int128.h"
-
-#if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
 #include <optional>
-#endif
 #include <string>
 #include <vector>
 
+#include "absl/base/config.h"
+#include "absl/numeric/int128.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -241,21 +238,6 @@ bool AbslParseFlag(absl::string_view, double*, std::string*);
 bool AbslParseFlag(absl::string_view, std::string*, std::string*);
 bool AbslParseFlag(absl::string_view, std::vector<std::string>*, std::string*);
 
-template <typename T>
-bool AbslParseFlag(absl::string_view text, absl::optional<T>* f,
-                   std::string* err) {
-  if (text.empty()) {
-    *f = absl::nullopt;
-    return true;
-  }
-  T value;
-  if (!absl::ParseFlag(text, &value, err)) return false;
-
-  *f = std::move(value);
-  return true;
-}
-
-#if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
 template <typename T>
 bool AbslParseFlag(absl::string_view text, std::optional<T>* f,
                    std::string* err) {
@@ -269,7 +251,6 @@ bool AbslParseFlag(absl::string_view text, std::optional<T>* f,
   *f = std::move(value);
   return true;
 }
-#endif
 
 template <typename T>
 bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) {
@@ -284,17 +265,10 @@ bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) {
 std::string AbslUnparseFlag(absl::string_view v);
 std::string AbslUnparseFlag(const std::vector<std::string>&);
 
-template <typename T>
-std::string AbslUnparseFlag(const absl::optional<T>& f) {
-  return f.has_value() ? absl::UnparseFlag(*f) : "";
-}
-
-#if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
 template <typename T>
 std::string AbslUnparseFlag(const std::optional<T>& f) {
   return f.has_value() ? absl::UnparseFlag(*f) : "";
 }
-#endif
 
 template <typename T>
 std::string Unparse(const T& v) {

data/third_party/abseil-cpp/absl/flags/reflection.cc

@@ -19,6 +19,7 @@
 
 #include <atomic>
 #include <string>
+#include <utility>
 
 #include "absl/base/config.h"
 #include "absl/base/no_destructor.h"
@@ -53,8 +54,11 @@ class FlagRegistry {
   // Store a flag in this registry. Takes ownership of *flag.
   void RegisterFlag(CommandLineFlag& flag, const char* filename);
 
-  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); }
-  void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.Unlock(); }
+  void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.lock(); }
+  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock(); }
+
+  void unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.unlock(); }
+  inline void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { unlock(); }
 
   // Returns the flag object for the specified name, or nullptr if not found.
   // Will emit a warning if a 'retired' flag is specified.
@@ -87,8 +91,8 @@ namespace {
 
 class FlagRegistryLock {
  public:
-  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.Lock(); }
-  ~FlagRegistryLock() { fr_.Unlock(); }
+  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.lock(); }
+  ~FlagRegistryLock() { fr_.unlock(); }
 
  private:
   FlagRegistry& fr_;
@@ -317,9 +321,9 @@ class FlagSaverImpl {
   }
 
   // Restores the saved flag states into the flag registry.
-  void RestoreToRegistry() {
+  void RestoreToRegistry() && {
     for (const auto& flag_state : backup_registry_) {
-      flag_state->Restore();
+      std::move(*flag_state).Restore();
     }
   }
 
@@ -337,7 +341,7 @@ FlagSaver::FlagSaver() : impl_(new flags_internal::FlagSaverImpl) {
 FlagSaver::~FlagSaver() {
   if (!impl_) return;
 
-  impl_->RestoreToRegistry();
+  std::move(*impl_).RestoreToRegistry();
   delete impl_;
 }
 

data/third_party/abseil-cpp/absl/flags/usage_config.cc

@@ -105,9 +105,9 @@ std::string NormalizeFilename(absl::string_view filename) {
 
 // --------------------------------------------------------------------
 
-absl::Mutex* CustomUsageConfigMutex() {
+absl::Mutex& CustomUsageConfigMutex() {
   static absl::NoDestructor<absl::Mutex> mutex;
-  return mutex.get();
+  return *mutex;
 }
 ABSL_CONST_INIT FlagsUsageConfig* custom_usage_config
     ABSL_GUARDED_BY(CustomUsageConfigMutex())

data/third_party/abseil-cpp/absl/functional/any_invocable.h

@@ -39,7 +39,9 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/nullability.h"
 #include "absl/functional/internal/any_invocable.h"
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
@@ -158,7 +160,8 @@ ABSL_NAMESPACE_BEGIN
 //   AnyInvocable<void()> empty;
 //   empty();  // WARNING: Undefined behavior!
 template <class Sig>
-class AnyInvocable : private internal_any_invocable::Impl<Sig> {
+class ABSL_NULLABILITY_COMPATIBLE ABSL_ATTRIBUTE_OWNER AnyInvocable
+    : private internal_any_invocable::Impl<Sig> {
  private:
   static_assert(
       std::is_function<Sig>::value,
@@ -169,6 +172,7 @@ class AnyInvocable : private internal_any_invocable::Impl<Sig> {
  public:
   // The return type of Sig
   using result_type = typename Impl::result_type;
+  using absl_internal_is_view = std::false_type;
 
   // Constructors
 
@@ -187,7 +191,7 @@ class AnyInvocable : private internal_any_invocable::Impl<Sig> {
   // Upon construction, `*this` is only empty if `f` is a function pointer or
   // member pointer type and is null, or if `f` is an `AnyInvocable` that is
   // empty.
-  template <class F, typename = absl::enable_if_t<
+  template <class F, typename = std::enable_if_t<
                          internal_any_invocable::CanConvert<Sig, F>::value>>
   AnyInvocable(F&& f)  // NOLINT
       : Impl(internal_any_invocable::ConversionConstruct(),
@@ -199,28 +203,27 @@ class AnyInvocable : private internal_any_invocable::Impl<Sig> {
   // Example:
   //
   //   AnyInvocable<int(int)> func(
-  //       absl::in_place_type<PossiblyImmovableType>, arg1, arg2);
+  //       std::in_place_type<PossiblyImmovableType>, arg1, arg2);
   //
   template <class T, class... Args,
-            typename = absl::enable_if_t<
+            typename = std::enable_if_t<
                 internal_any_invocable::CanEmplace<Sig, T, Args...>::value>>
-  explicit AnyInvocable(absl::in_place_type_t<T>, Args&&... args)
-      : Impl(absl::in_place_type<absl::decay_t<T>>,
-             std::forward<Args>(args)...) {
-    static_assert(std::is_same<T, absl::decay_t<T>>::value,
+  explicit AnyInvocable(std::in_place_type_t<T>, Args&&... args)
+      : Impl(std::in_place_type<std::decay_t<T>>, std::forward<Args>(args)...) {
+    static_assert(std::is_same<T, std::decay_t<T>>::value,
                   "The explicit template argument of in_place_type is required "
                   "to be an unqualified object type.");
   }
 
   // Overload of the above constructor to support list-initialization.
   template <class T, class U, class... Args,
-            typename = absl::enable_if_t<internal_any_invocable::CanEmplace<
+            typename = std::enable_if_t<internal_any_invocable::CanEmplace<
                 Sig, T, std::initializer_list<U>&, Args...>::value>>
-  explicit AnyInvocable(absl::in_place_type_t<T>,
-                        std::initializer_list<U> ilist, Args&&... args)
-      : Impl(absl::in_place_type<absl::decay_t<T>>, ilist,
+  explicit AnyInvocable(std::in_place_type_t<T>, std::initializer_list<U> ilist,
+                        Args&&... args)
+      : Impl(std::in_place_type<std::decay_t<T>>, ilist,
              std::forward<Args>(args)...) {
-    static_assert(std::is_same<T, absl::decay_t<T>>::value,
+    static_assert(std::is_same<T, std::decay_t<T>>::value,
                   "The explicit template argument of in_place_type is required "
                   "to be an unqualified object type.");
   }
@@ -244,7 +247,7 @@ class AnyInvocable : private internal_any_invocable::Impl<Sig> {
   // Upon assignment, `*this` is only empty if `f` is a function pointer or
   // member pointer type and is null, or if `f` is an `AnyInvocable` that is
   // empty.
-  template <class F, typename = absl::enable_if_t<
+  template <class F, typename = std::enable_if_t<
                          internal_any_invocable::CanAssign<Sig, F>::value>>
   AnyInvocable& operator=(F&& f) {
     *this = AnyInvocable(std::forward<F>(f));
@@ -256,7 +259,7 @@ class AnyInvocable : private internal_any_invocable::Impl<Sig> {
   // `AnyInvocable` instance.
   template <
       class F,
-      typename = absl::enable_if_t<
+      typename = std::enable_if_t<
           internal_any_invocable::CanAssignReferenceWrapper<Sig, F>::value>>
   AnyInvocable& operator=(std::reference_wrapper<F> f) noexcept {
     *this = AnyInvocable(f);
@@ -295,22 +298,22 @@ class AnyInvocable : private internal_any_invocable::Impl<Sig> {
 
   // Equality operators
 
-  // Returns `true` if `*this` is empty.
+  // Returns `true` if `f` is empty.
   friend bool operator==(const AnyInvocable& f, std::nullptr_t) noexcept {
     return !f.HasValue();
   }
 
-  // Returns `true` if `*this` is empty.
+  // Returns `true` if `f` is empty.
   friend bool operator==(std::nullptr_t, const AnyInvocable& f) noexcept {
     return !f.HasValue();
   }
 
-  // Returns `false` if `*this` is empty.
+  // Returns `false` if `f` is empty.
   friend bool operator!=(const AnyInvocable& f, std::nullptr_t) noexcept {
     return f.HasValue();
   }
 
-  // Returns `false` if `*this` is empty.
+  // Returns `false` if `f` is empty.
   friend bool operator!=(std::nullptr_t, const AnyInvocable& f) noexcept {
     return f.HasValue();
   }

data/third_party/abseil-cpp/absl/functional/bind_front.h

@@ -30,6 +30,12 @@
 #ifndef ABSL_FUNCTIONAL_BIND_FRONT_H_
 #define ABSL_FUNCTIONAL_BIND_FRONT_H_
 
+#ifdef __has_include
+#if __has_include(<version>)
+#include <version>
+#endif
+#endif
+
 #if defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
 #include <functional>  // For std::bind_front.
 #endif  // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
@@ -184,7 +190,7 @@ template <class F, class... BoundArgs>
 constexpr functional_internal::bind_front_t<F, BoundArgs...> bind_front(
     F&& func, BoundArgs&&... args) {
   return functional_internal::bind_front_t<F, BoundArgs...>(
-      absl::in_place, std::forward<F>(func), std::forward<BoundArgs>(args)...);
+      std::in_place, std::forward<F>(func), std::forward<BoundArgs>(args)...);
 }
 #endif  // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L