re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/flags/internal/flag.h

@@ -57,7 +57,7 @@ template <typename T>
 using Flag = flags_internal::Flag<T>;
 
 template <typename T>
-ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag);
+[[nodiscard]] T GetFlag(const absl::Flag<T>& flag);
 
 template <typename T>
 void SetFlag(absl::Flag<T>* flag, const T& v);
@@ -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>() ==
                                   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
@@ -783,7 +782,7 @@ class FlagImpl final : public CommandLineFlag {
   // heap allocation during initialization, which is both slows program startup
   // and can fail. Using reserved space + placement new allows us to avoid both
   // problems.
-  alignas(absl::Mutex) mutable char data_guard_[sizeof(absl::Mutex)];
+  alignas(absl::Mutex) mutable unsigned char data_guard_[sizeof(absl::Mutex)];
 };
 #if defined(__GNUC__) && !defined(__clang__)
 #pragma GCC diagnostic pop
@@ -828,7 +827,7 @@ class Flag {
     U u;
 
 #if !defined(NDEBUG)
-    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
 #endif
 
     if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
@@ -837,7 +836,7 @@ class Flag {
     return std::move(u.value);
   }
   void Set(const T& v) {
-    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+    impl_.AssertValidType(absl::FastTypeId<T>(), &GenRuntimeTypeId<T>);
     impl_.Write(&v);
   }
 
@@ -876,7 +875,8 @@ class FlagImplPeer {
 template <typename T>
 void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
   struct AlignedSpace {
-    alignas(MaskedPointer::RequiredAlignment()) alignas(T) char buf[sizeof(T)];
+    alignas(MaskedPointer::RequiredAlignment()) alignas(
+        T) unsigned char buf[sizeof(T)];
   };
   using Allocator = std::allocator<AlignedSpace>;
   switch (op) {
@@ -901,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*>(base_internal::FastTypeId<T>());
+      return const_cast<void*>(absl::FastTypeId<T>());
     case FlagOp::kRuntimeTypeId:
       return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
     case FlagOp::kParse: {

package/vendor/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;

package/vendor/abseil-cpp/absl/flags/internal/registry.h

@@ -19,6 +19,7 @@
 #include <functional>
 
 #include "absl/base/config.h"
+#include "absl/base/fast_type_id.h"
 #include "absl/flags/commandlineflag.h"
 #include "absl/flags/internal/commandlineflag.h"
 #include "absl/strings/string_view.h"
@@ -73,7 +74,7 @@ void FinalizeRegistry();
 //
 
 // Retire flag with name "name" and type indicated by ops.
-void Retire(const char* name, FlagFastTypeId type_id, char* buf);
+void Retire(const char* name, FlagFastTypeId type_id, unsigned char* buf);
 
 constexpr size_t kRetiredFlagObjSize = 3 * sizeof(void*);
 constexpr size_t kRetiredFlagObjAlignment = alignof(void*);
@@ -83,11 +84,11 @@ template <typename T>
 class RetiredFlag {
  public:
   void Retire(const char* flag_name) {
-    flags_internal::Retire(flag_name, base_internal::FastTypeId<T>(), buf_);
+    flags_internal::Retire(flag_name, absl::FastTypeId<T>(), buf_);
   }
 
  private:
-  alignas(kRetiredFlagObjAlignment) char buf_[kRetiredFlagObjSize];
+  alignas(kRetiredFlagObjAlignment) unsigned char buf_[kRetiredFlagObjSize];
 };
 
 }  // namespace flags_internal

package/vendor/abseil-cpp/absl/flags/internal/usage.cc

@@ -434,9 +434,9 @@ HelpMode HandleUsageFlags(std::ostream& out,
 
 namespace {
 
-absl::Mutex* HelpAttributesMutex() {
+absl::Mutex& HelpAttributesMutex() {
   static absl::NoDestructor<absl::Mutex> mutex;
-  return mutex.get();
+  return *mutex;
 }
 ABSL_CONST_INIT std::string* match_substr ABSL_GUARDED_BY(HelpAttributesMutex())
     ABSL_PT_GUARDED_BY(HelpAttributesMutex()) = nullptr;

package/vendor/abseil-cpp/absl/flags/parse.cc

@@ -64,9 +64,9 @@ ABSL_NAMESPACE_BEGIN
 namespace flags_internal {
 namespace {
 
-absl::Mutex* ProcessingChecksMutex() {
+absl::Mutex& ProcessingChecksMutex() {
   static absl::NoDestructor<absl::Mutex> mutex;
-  return mutex.get();
+  return *mutex;
 }
 
 ABSL_CONST_INIT bool flagfile_needs_processing
@@ -76,9 +76,13 @@ ABSL_CONST_INIT bool fromenv_needs_processing
 ABSL_CONST_INIT bool tryfromenv_needs_processing
     ABSL_GUARDED_BY(ProcessingChecksMutex()) = false;
 
-ABSL_CONST_INIT absl::Mutex specified_flags_guard(absl::kConstInit);
+absl::Mutex& SpecifiedFlagsMutex() {
+  static absl::NoDestructor<absl::Mutex> mutex;
+  return *mutex;
+}
+
 ABSL_CONST_INIT std::vector<const CommandLineFlag*>* specified_flags
-    ABSL_GUARDED_BY(specified_flags_guard) = nullptr;
+    ABSL_GUARDED_BY(SpecifiedFlagsMutex()) = nullptr;
 
 // Suggesting at most kMaxHints flags in case of misspellings.
 ABSL_CONST_INIT const size_t kMaxHints = 100;
@@ -640,7 +644,7 @@ void ReportUnrecognizedFlags(
 // --------------------------------------------------------------------
 
 bool WasPresentOnCommandLine(absl::string_view flag_name) {
-  absl::ReaderMutexLock l(&specified_flags_guard);
+  absl::ReaderMutexLock l(SpecifiedFlagsMutex());
   ABSL_INTERNAL_CHECK(specified_flags != nullptr,
                       "ParseCommandLine is not invoked yet");
 
@@ -767,7 +771,7 @@ HelpMode ParseAbseilFlagsOnlyImpl(
   }
   positional_args.push_back(argv[0]);
 
-  absl::MutexLock l(&flags_internal::specified_flags_guard);
+  absl::MutexLock l(flags_internal::SpecifiedFlagsMutex());
   if (specified_flags == nullptr) {
     specified_flags = new std::vector<const CommandLineFlag*>;
   } else {

package/vendor/abseil-cpp/absl/flags/reflection.cc

@@ -53,8 +53,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 +90,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_;
@@ -289,11 +292,10 @@ class RetiredFlagObj final : public CommandLineFlag {
 
 }  // namespace
 
-void Retire(const char* name, FlagFastTypeId type_id, char* buf) {
+void Retire(const char* name, FlagFastTypeId type_id, unsigned char* buf) {
   static_assert(sizeof(RetiredFlagObj) == kRetiredFlagObjSize, "");
   static_assert(alignof(RetiredFlagObj) == kRetiredFlagObjAlignment, "");
-  auto* flag = ::new (static_cast<void*>(buf))
-      flags_internal::RetiredFlagObj(name, type_id);
+  auto* flag = ::new (buf) flags_internal::RetiredFlagObj(name, type_id);
   FlagRegistry::GlobalRegistry().RegisterFlag(*flag, nullptr);
 }
 

package/vendor/abseil-cpp/absl/flags/usage.cc

@@ -40,7 +40,7 @@ ABSL_CONST_INIT std::string* program_usage_message
 // --------------------------------------------------------------------
 // Sets the "usage" message to be used by help reporting routines.
 void SetProgramUsageMessage(absl::string_view new_usage_message) {
-  absl::MutexLock l(&flags_internal::usage_message_guard);
+  absl::MutexLock l(flags_internal::usage_message_guard);
 
   if (flags_internal::program_usage_message != nullptr) {
     ABSL_INTERNAL_LOG(FATAL, "SetProgramUsageMessage() called twice.");
@@ -55,7 +55,7 @@ void SetProgramUsageMessage(absl::string_view new_usage_message) {
 // Note: We able to return string_view here only because calling
 // SetProgramUsageMessage twice is prohibited.
 absl::string_view ProgramUsageMessage() {
-  absl::MutexLock l(&flags_internal::usage_message_guard);
+  absl::MutexLock l(flags_internal::usage_message_guard);
 
   return flags_internal::program_usage_message != nullptr
              ? absl::string_view(*flags_internal::program_usage_message)

package/vendor/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())

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

@@ -14,6 +14,9 @@
 # limitations under the License.
 #
 
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
 load(
     "//absl:copts/configure_copts.bzl",
     "ABSL_DEFAULT_COPTS",
@@ -39,9 +42,9 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
-        "//absl/base:base_internal",
         "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/base:nullability",
         "//absl/meta:type_traits",
         "//absl/utility",
     ],
@@ -57,9 +60,9 @@ cc_test(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":any_invocable",
-        "//absl/base:base_internal",
         "//absl/base:config",
         "//absl/base:core_headers",
+        "//absl/base:nullability",
         "//absl/meta:type_traits",
         "//absl/utility",
         "@googletest//:gtest",
@@ -74,7 +77,6 @@ cc_library(
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
-        "//absl/base:base_internal",
         "//absl/container:compressed_tuple",
         "//absl/meta:type_traits",
         "//absl/utility",
@@ -102,7 +104,6 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         ":any_invocable",
-        "//absl/base:base_internal",
         "//absl/base:core_headers",
         "//absl/meta:type_traits",
     ],
@@ -150,8 +151,9 @@ cc_test(
     ],
 )
 
-cc_test(
+cc_binary(
     name = "function_type_benchmark",
+    testonly = True,
     srcs = [
         "function_type_benchmark.cc",
     ],
@@ -163,6 +165,5 @@ cc_test(
         ":function_ref",
         "//absl/base:core_headers",
         "@google_benchmark//:benchmark_main",
-        "@googletest//:gtest",
     ],
 )

package/vendor/abseil-cpp/absl/functional/CMakeLists.txt

@@ -24,7 +24,7 @@ absl_cc_library(
   COPTS
     ${ABSL_DEFAULT_COPTS}
   DEPS
-    absl::base_internal
+    absl::base
     absl::config
     absl::core_headers
     absl::type_traits
@@ -42,7 +42,7 @@ absl_cc_test(
     ${ABSL_TEST_COPTS}
   DEPS
     absl::any_invocable
-    absl::base_internal
+    absl::base
     absl::config
     absl::core_headers
     absl::type_traits
@@ -60,7 +60,6 @@ absl_cc_library(
   COPTS
     ${ABSL_DEFAULT_COPTS}
   DEPS
-    absl::base_internal
     absl::compressed_tuple
   PUBLIC
 )
@@ -88,7 +87,6 @@ absl_cc_library(
   COPTS
     ${ABSL_DEFAULT_COPTS}
   DEPS
-    absl::base_internal
     absl::core_headers
     absl::any_invocable
     absl::meta

package/vendor/abseil-cpp/absl/functional/any_invocable.h

@@ -25,7 +25,7 @@
 //
 // NOTE: `absl::AnyInvocable` is similar to the C++23 `std::move_only_function`
 // abstraction, but has a slightly different API and is not designed to be a
-// drop-in replacement or C++11-compatible backfill of that type.
+// drop-in replacement or backfill of that type.
 //
 // Credits to Matt Calabrese (https://github.com/mattcalabrese) for the original
 // implementation.
@@ -40,6 +40,7 @@
 #include <utility>
 
 #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"
@@ -97,11 +98,10 @@ ABSL_NAMESPACE_BEGIN
 // my_func(std::move(func6));
 //
 // `AnyInvocable` also properly respects `const` qualifiers, reference
-// qualifiers, and the `noexcept` specification (only in C++ 17 and beyond) as
-// part of the user-specified function type (e.g.
-// `AnyInvocable<void() const && noexcept>`). These qualifiers will be applied
-// to the `AnyInvocable` object's `operator()`, and the underlying invocable
-// must be compatible with those qualifiers.
+// qualifiers, and the `noexcept` specification  as part of the user-specified
+// function type (e.g. `AnyInvocable<void() const && noexcept>`). These
+// qualifiers will be applied to the `AnyInvocable` object's `operator()`, and
+// the underlying invocable must be compatible with those qualifiers.
 //
 // Comparison of const and non-const function types:
 //
@@ -159,7 +159,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 AnyInvocable
+    : private internal_any_invocable::Impl<Sig> {
  private:
   static_assert(
       std::is_function<Sig>::value,
@@ -280,11 +281,10 @@ class AnyInvocable : private internal_any_invocable::Impl<Sig> {
   //
   // WARNING: An `AnyInvocable` that wraps an empty `std::function` is not
   // itself empty. This behavior is consistent with the standard equivalent
-  // `std::move_only_function`.
-  //
-  // In other words:
+  // `std::move_only_function`. In the following example, `a()` will actually
+  // invoke `f()`, leading to an `std::bad_function_call` exception:
   //   std::function<void()> f;  // empty
-  //   absl::AnyInvocable<void()> a = std::move(f);  // not empty
+  //   absl::AnyInvocable<void()> a = f;  // not empty
   //
   // Invoking an empty `AnyInvocable` results in undefined behavior.
   explicit operator bool() const noexcept { return this->HasValue(); }
@@ -297,22 +297,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();
   }