re2 1.24.1 → 1.25.0

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

@@ -19,6 +19,7 @@
 #include <stdint.h>
 
 #include <atomic>
+#include <optional>
 #include <string>
 #include <thread>  // NOLINT
 #include <vector>
@@ -42,7 +43,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 
 ABSL_DECLARE_FLAG(int64_t, mistyped_int_flag);
 ABSL_DECLARE_FLAG(std::vector<std::string>, mistyped_string_flag);
@@ -1038,7 +1038,7 @@ std::string AbslUnparseFlag(const NonTriviallyCopyableUDT<id>&) {
 template <int id, typename F>
 void TestExpectedLeaks(
     F&& f, uint64_t num_leaks,
-    absl::optional<uint64_t> num_new_instances = absl::nullopt) {
+    std::optional<uint64_t> num_new_instances = std::nullopt) {
   if (!num_new_instances.has_value()) num_new_instances = num_leaks;
 
   auto num_leaked_before = flags::NumLeakedFlagValues();
@@ -1216,14 +1216,14 @@ TEST_F(FlagTest, MacroWithinAbslFlag) {
 
 // --------------------------------------------------------------------
 
-ABSL_FLAG(absl::optional<bool>, optional_bool, absl::nullopt, "help");
-ABSL_FLAG(absl::optional<int>, optional_int, {}, "help");
-ABSL_FLAG(absl::optional<double>, optional_double, 9.3, "help");
-ABSL_FLAG(absl::optional<std::string>, optional_string, absl::nullopt, "help");
-ABSL_FLAG(absl::optional<absl::Duration>, optional_duration, absl::nullopt,
+ABSL_FLAG(std::optional<bool>, optional_bool, std::nullopt, "help");
+ABSL_FLAG(std::optional<int>, optional_int, {}, "help");
+ABSL_FLAG(std::optional<double>, optional_double, 9.3, "help");
+ABSL_FLAG(std::optional<std::string>, optional_string, std::nullopt, "help");
+ABSL_FLAG(std::optional<absl::Duration>, optional_duration, std::nullopt,
           "help");
-ABSL_FLAG(absl::optional<absl::optional<int>>, optional_optional_int,
-          absl::nullopt, "help");
+ABSL_FLAG(std::optional<std::optional<int>>, optional_optional_int,
+          std::nullopt, "help");
 #if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
 ABSL_FLAG(std::optional<int64_t>, std_optional_int64, std::nullopt, "help");
 #endif
@@ -1232,7 +1232,7 @@ namespace {
 
 TEST_F(FlagTest, TestOptionalBool) {
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_bool).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), std::nullopt);
 
   absl::SetFlag(&FLAGS_optional_bool, false);
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_bool).has_value());
@@ -1242,16 +1242,16 @@ TEST_F(FlagTest, TestOptionalBool) {
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_bool).has_value());
   EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), true);
 
-  absl::SetFlag(&FLAGS_optional_bool, absl::nullopt);
+  absl::SetFlag(&FLAGS_optional_bool, std::nullopt);
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_bool).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), std::nullopt);
 }
 
 // --------------------------------------------------------------------
 
 TEST_F(FlagTest, TestOptionalInt) {
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_int).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), std::nullopt);
 
   absl::SetFlag(&FLAGS_optional_int, 0);
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_int).has_value());
@@ -1261,9 +1261,9 @@ TEST_F(FlagTest, TestOptionalInt) {
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_int).has_value());
   EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), 10);
 
-  absl::SetFlag(&FLAGS_optional_int, absl::nullopt);
+  absl::SetFlag(&FLAGS_optional_int, std::nullopt);
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_int).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), std::nullopt);
 }
 
 // --------------------------------------------------------------------
@@ -1280,16 +1280,16 @@ TEST_F(FlagTest, TestOptionalDouble) {
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_double).has_value());
   EXPECT_DOUBLE_EQ(*absl::GetFlag(FLAGS_optional_double), 1.234);
 
-  absl::SetFlag(&FLAGS_optional_double, absl::nullopt);
+  absl::SetFlag(&FLAGS_optional_double, std::nullopt);
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_double).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_double), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_double), std::nullopt);
 }
 
 // --------------------------------------------------------------------
 
 TEST_F(FlagTest, TestOptionalString) {
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_string).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), std::nullopt);
 
   // Setting optional string to "" leads to undefined behavior.
 
@@ -1301,16 +1301,16 @@ TEST_F(FlagTest, TestOptionalString) {
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_string).has_value());
   EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), "QWERTY");
 
-  absl::SetFlag(&FLAGS_optional_string, absl::nullopt);
+  absl::SetFlag(&FLAGS_optional_string, std::nullopt);
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_string).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), std::nullopt);
 }
 
 // --------------------------------------------------------------------
 
 TEST_F(FlagTest, TestOptionalDuration) {
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_duration).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), std::nullopt);
 
   absl::SetFlag(&FLAGS_optional_duration, absl::ZeroDuration());
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_duration).has_value());
@@ -1320,37 +1320,37 @@ TEST_F(FlagTest, TestOptionalDuration) {
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_duration).has_value());
   EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), absl::Hours(3));
 
-  absl::SetFlag(&FLAGS_optional_duration, absl::nullopt);
+  absl::SetFlag(&FLAGS_optional_duration, std::nullopt);
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_duration).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), std::nullopt);
 }
 
 // --------------------------------------------------------------------
 
 TEST_F(FlagTest, TestOptionalOptional) {
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), std::nullopt);
 
-  absl::optional<int> nullint{absl::nullopt};
+  std::optional<int> nullint{std::nullopt};
 
   absl::SetFlag(&FLAGS_optional_optional_int, nullint);
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
   EXPECT_NE(absl::GetFlag(FLAGS_optional_optional_int), nullint);
   EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int),
-            absl::optional<absl::optional<int>>{nullint});
+            std::optional<std::optional<int>>{nullint});
 
   absl::SetFlag(&FLAGS_optional_optional_int, 0);
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
   EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), 0);
 
-  absl::SetFlag(&FLAGS_optional_optional_int, absl::optional<int>{0});
+  absl::SetFlag(&FLAGS_optional_optional_int, std::optional<int>{0});
   EXPECT_TRUE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
   EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), 0);
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), absl::optional<int>{0});
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), std::optional<int>{0});
 
-  absl::SetFlag(&FLAGS_optional_optional_int, absl::nullopt);
+  absl::SetFlag(&FLAGS_optional_optional_int, std::nullopt);
   EXPECT_FALSE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
-  EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), absl::nullopt);
+  EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), std::nullopt);
 }
 
 // --------------------------------------------------------------------

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

@@ -443,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());
     }
@@ -454,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()),

package/vendor/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>
@@ -608,7 +608,7 @@ class FlagImpl final : public CommandLineFlag {
     *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()) {
@@ -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*>(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: {

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

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

@@ -19,6 +19,7 @@
 
 #include <cmath>
 #include <limits>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -777,7 +778,7 @@ TEST(MarshallingTest, TestVectorOfStringParsing) {
 
 TEST(MarshallingTest, TestOptionalBoolParsing) {
   std::string err;
-  absl::optional<bool> value;
+  std::optional<bool> value;
 
   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
   EXPECT_FALSE(value.has_value());
@@ -797,7 +798,7 @@ TEST(MarshallingTest, TestOptionalBoolParsing) {
 
 TEST(MarshallingTest, TestOptionalIntParsing) {
   std::string err;
-  absl::optional<int> value;
+  std::optional<int> value;
 
   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
   EXPECT_FALSE(value.has_value());
@@ -817,7 +818,7 @@ TEST(MarshallingTest, TestOptionalIntParsing) {
 
 TEST(MarshallingTest, TestOptionalDoubleParsing) {
   std::string err;
-  absl::optional<double> value;
+  std::optional<double> value;
 
   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
   EXPECT_FALSE(value.has_value());
@@ -837,7 +838,7 @@ TEST(MarshallingTest, TestOptionalDoubleParsing) {
 
 TEST(MarshallingTest, TestOptionalStringParsing) {
   std::string err;
-  absl::optional<std::string> value;
+  std::optional<std::string> value;
 
   EXPECT_TRUE(absl::ParseFlag("", &value, &err));
   EXPECT_FALSE(value.has_value());
@@ -1041,49 +1042,49 @@ TEST(MarshallingTest, TestStringUnparsing) {
 // --------------------------------------------------------------------
 
 TEST(MarshallingTest, TestOptionalBoolUnparsing) {
-  absl::optional<bool> value;
+  std::optional<bool> value;
 
   EXPECT_EQ(absl::UnparseFlag(value), "");
   value = true;
   EXPECT_EQ(absl::UnparseFlag(value), "true");
   value = false;
   EXPECT_EQ(absl::UnparseFlag(value), "false");
-  value = absl::nullopt;
+  value = std::nullopt;
   EXPECT_EQ(absl::UnparseFlag(value), "");
 }
 
 // --------------------------------------------------------------------
 
 TEST(MarshallingTest, TestOptionalIntUnparsing) {
-  absl::optional<int> value;
+  std::optional<int> value;
 
   EXPECT_EQ(absl::UnparseFlag(value), "");
   value = 0;
   EXPECT_EQ(absl::UnparseFlag(value), "0");
   value = -12;
   EXPECT_EQ(absl::UnparseFlag(value), "-12");
-  value = absl::nullopt;
+  value = std::nullopt;
   EXPECT_EQ(absl::UnparseFlag(value), "");
 }
 
 // --------------------------------------------------------------------
 
 TEST(MarshallingTest, TestOptionalDoubleUnparsing) {
-  absl::optional<double> value;
+  std::optional<double> value;
 
   EXPECT_EQ(absl::UnparseFlag(value), "");
   value = 1.;
   EXPECT_EQ(absl::UnparseFlag(value), "1");
   value = -1.23;
   EXPECT_EQ(absl::UnparseFlag(value), "-1.23");
-  value = absl::nullopt;
+  value = std::nullopt;
   EXPECT_EQ(absl::UnparseFlag(value), "");
 }
 
 // --------------------------------------------------------------------
 
 TEST(MarshallingTest, TestOptionalStringUnparsing) {
-  absl::optional<std::string> strvalue;
+  std::optional<std::string> strvalue;
   EXPECT_EQ(absl::UnparseFlag(strvalue), "");
 
   strvalue = "asdfg";

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

@@ -38,7 +38,7 @@ class ReflectionTest : public testing::Test {
 #if ABSL_FLAGS_STRIP_NAMES
     GTEST_SKIP() << "This test requires flag names to be present";
 #endif
-    flag_saver_ = absl::make_unique<absl::FlagSaver>();
+    flag_saver_ = std::make_unique<absl::FlagSaver>();
   }
   void TearDown() override { flag_saver_.reset(); }
 

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

@@ -70,6 +70,32 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "bind_back",
+    srcs = ["internal/back_binder.h"],
+    hdrs = ["bind_back.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        "//absl/base:config",
+        "//absl/container:compressed_tuple",
+        "//absl/utility",
+    ],
+)
+
+cc_test(
+    name = "bind_back_test",
+    srcs = ["bind_back_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":bind_back",
+        "//absl/memory",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "bind_front",
     srcs = ["internal/front_binder.h"],
@@ -149,7 +175,6 @@ cc_test(
         "//absl/base:config",
         "//absl/strings",
         "//absl/strings:string_view",
-        "//absl/types:variant",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],

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

@@ -50,6 +50,35 @@ absl_cc_test(
     GTest::gmock_main
 )
 
+absl_cc_library(
+  NAME
+    bind_back
+  SRCS
+    "internal/back_binder.h"
+  HDRS
+    "bind_back.h"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::compressed_tuple
+    absl::config
+    absl::utility
+  PUBLIC
+)
+
+absl_cc_test(
+  NAME
+    bind_back_test
+  SRCS
+    "bind_back_test.cc"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::bind_back
+    absl::memory
+    GTest::gmock_main
+)
+
 absl_cc_library(
   NAME
     bind_front
@@ -135,6 +164,5 @@ absl_cc_test(
     absl::overload
     absl::string_view
     absl::strings
-    absl::variant
     GTest::gmock_main
 )

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

@@ -191,7 +191,7 @@ class ABSL_NULLABILITY_COMPATIBLE ABSL_ATTRIBUTE_OWNER AnyInvocable
   // 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(),
@@ -203,28 +203,27 @@ class ABSL_NULLABILITY_COMPATIBLE ABSL_ATTRIBUTE_OWNER AnyInvocable
   // 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.");
   }
@@ -248,7 +247,7 @@ class ABSL_NULLABILITY_COMPATIBLE ABSL_ATTRIBUTE_OWNER AnyInvocable
   // 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));
@@ -260,7 +259,7 @@ class ABSL_NULLABILITY_COMPATIBLE ABSL_ATTRIBUTE_OWNER AnyInvocable
   // `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);