grpc 1.84.0 → 1.85.0.pre1

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

@@ -47,12 +47,14 @@
 #define ABSL_FUNCTIONAL_FUNCTION_REF_H_
 
 #include <cassert>
-#include <functional>
 #include <type_traits>
+#include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/base/config.h"
 #include "absl/functional/internal/function_ref.h"
 #include "absl/meta/type_traits.h"
+#include "absl/utility/utility.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -83,42 +85,80 @@ class FunctionRef;
 //   bool Visitor(absl::FunctionRef<void(my_proto&, absl::string_view)>
 //                  callback);
 template <typename R, typename... Args>
-class FunctionRef<R(Args...)> {
- private:
+class ABSL_ATTRIBUTE_VIEW FunctionRef<R(Args...)> {
+ protected:
   // Used to disable constructors for objects that are not compatible with the
   // signature of this FunctionRef.
-  template <typename F, typename FR = std::invoke_result_t<F, Args&&...>>
+  template <typename F, typename... U>
   using EnableIfCompatible =
-      typename std::enable_if<std::is_void<R>::value ||
-                              std::is_convertible<FR, R>::value>::type;
+      std::enable_if_t<std::is_invocable_r<R, F, U..., Args...>::value>;
 
- public:
-  // Constructs a FunctionRef from any invocable type.
-  template <typename F, typename = EnableIfCompatible<const F&>>
-  // NOLINTNEXTLINE(runtime/explicit)
-  FunctionRef(const F& f ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
+  // Internal constructor to supersede the copying constructor
+  template <typename F>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(std::in_place_t, F&& f ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
     absl::functional_internal::AssertNonNull(f);
     ptr_.obj = &f;
   }
 
+ public:
+  // Constructs a FunctionRef from any invocable type.
+  template <typename F,
+            typename = EnableIfCompatible<std::enable_if_t<
+                !std::is_same_v<FunctionRef, absl::remove_cvref_t<F>>, F&>>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(F&& f ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : FunctionRef(std::in_place, std::forward<F>(f)) {}
+
   // Overload for function pointers. This eliminates a level of indirection that
   // would happen if the above overload was used (it lets us store the pointer
   // instead of a pointer to a pointer).
   //
   // This overload is also used for references to functions, since references to
   // functions can decay to function pointers implicitly.
-  template <
-      typename F, typename = EnableIfCompatible<F*>,
-      absl::functional_internal::EnableIf<absl::is_function<F>::value> = 0>
-  FunctionRef(F* f)  // NOLINT(runtime/explicit)
+  template <typename F, typename = EnableIfCompatible<F*>,
+            absl::functional_internal::EnableIf<std::is_function_v<F>> = 0>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(F* f ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
       : invoker_(&absl::functional_internal::InvokeFunction<F*, R, Args...>) {
     assert(f != nullptr);
     ptr_.fun = reinterpret_cast<decltype(ptr_.fun)>(f);
   }
 
-  FunctionRef& operator=(const FunctionRef& rhs) = default;
-  FunctionRef(const FunctionRef& rhs) = default;
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+  // Similar to the other overloads, but passes the address of a known callable
+  // `F` at compile time. This allows calling arbitrary functions while avoiding
+  // an indirection.
+  // Needs C++20 as `nontype_t` needs C++20 for `auto` template parameters.
+  template <auto F, typename = EnableIfCompatible<decltype(F)>>
+  FunctionRef(nontype_t<F>) noexcept  // NOLINT(google-explicit-constructor)
+      : invoker_(&absl::functional_internal::InvokeFunction<decltype(F), F, R,
+                                                            Args...>) {}
+
+  template <
+      auto F, typename Obj,
+      typename = EnableIfCompatible<decltype(F), std::remove_reference_t<Obj>&>,
+      absl::functional_internal::EnableIf<!std::is_rvalue_reference_v<Obj&&>> =
+          0>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(nontype_t<F>, Obj&& obj ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : invoker_(&absl::functional_internal::InvokeObject<Obj&, decltype(F), F,
+                                                          R, Args...>) {
+    ptr_.obj = std::addressof(obj);
+  }
+
+  template <auto F, typename Obj,
+            typename = EnableIfCompatible<decltype(F), Obj*>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(nontype_t<F>, Obj* obj ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : invoker_(&absl::functional_internal::InvokePtr<Obj, decltype(F), F, R,
+                                                       Args...>) {
+    ptr_.obj = obj;
+  }
+#endif
+
+  using absl_internal_is_view = std::true_type;
 
   // Call the underlying object.
   R operator()(Args... args) const {
@@ -133,11 +173,76 @@ class FunctionRef<R(Args...)> {
 // Allow const qualified function signatures. Since FunctionRef requires
 // constness anyway we can just make this a no-op.
 template <typename R, typename... Args>
-class FunctionRef<R(Args...) const> : public FunctionRef<R(Args...)> {
+class ABSL_ATTRIBUTE_VIEW
+    FunctionRef<R(Args...) const> : private FunctionRef<R(Args...)> {
+  using Base = FunctionRef<R(Args...)>;
+
+  template <typename F, typename... U>
+  using EnableIfCompatible =
+      typename Base::template EnableIfCompatible<F, U...>;
+
  public:
-  using FunctionRef<R(Args...)>::FunctionRef;
+  template <
+      typename F,
+      typename = EnableIfCompatible<std::enable_if_t<
+          !std::is_same_v<FunctionRef, absl::remove_cvref_t<F>>, const F&>>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(const F& f ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : Base(std::in_place_t(), f) {}
+
+  template <typename F, typename = EnableIfCompatible<F*>,
+            absl::functional_internal::EnableIf<std::is_function_v<F>> = 0>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(F* f ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept : Base(f) {}
+
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+  template <auto F, typename = EnableIfCompatible<decltype(F)>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(nontype_t<F> arg) noexcept : Base(arg) {}
+
+  template <auto F, typename Obj,
+            typename = EnableIfCompatible<decltype(F),
+                                          const std::remove_reference_t<Obj>&>,
+            absl::functional_internal::EnableIf<
+                !std::is_rvalue_reference_v<Obj&&>> = 0>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(nontype_t<F> arg,
+              Obj&& obj ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : Base(arg, std::forward<Obj>(obj)) {}
+
+  template <auto F, typename Obj,
+            typename = EnableIfCompatible<decltype(F), const Obj*>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  FunctionRef(nontype_t<F> arg,
+              const Obj* obj ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : Base(arg, obj) {}
+#endif
+
+  using absl_internal_is_view = std::true_type;
+
+  using Base::operator();
 };
 
+template <class F>
+FunctionRef(F*) -> FunctionRef<F>;
+
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
+template <auto Func>
+FunctionRef(nontype_t<Func>)
+    -> FunctionRef<std::remove_pointer_t<decltype(Func)>>;
+
+template <class M, class T, M T::* Func, class U>
+FunctionRef(nontype_t<Func>, U&&)
+    -> FunctionRef<std::enable_if_t<std::is_member_pointer_v<M T::*>, M>>;
+
+template <class M, class T, M T::* Func, class U>
+FunctionRef(nontype_t<Func>, U&&) -> FunctionRef<std::enable_if_t<
+    std::is_object_v<M>, std::invoke_result_t<decltype(Func), U&>()>>;
+
+template <class R, class T, class... Args, R (*Func)(T, Args...), class U>
+FunctionRef(nontype_t<Func>, U&&) -> FunctionRef<R(Args...)>;
+#endif
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 

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

@@ -66,6 +66,7 @@
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/macros.h"
+#include "absl/base/nullability.h"
 #include "absl/base/optimization.h"
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
@@ -75,7 +76,7 @@ ABSL_NAMESPACE_BEGIN
 
 // Defined in functional/any_invocable.h
 template <class Sig>
-class AnyInvocable;
+class ABSL_NULLABILITY_COMPATIBLE AnyInvocable;
 
 namespace internal_any_invocable {
 
@@ -158,10 +159,18 @@ using ForwardedParameterType = typename ForwardedParameter<T>::type;
 // A discriminator when calling the "manager" function that describes operation
 // type-erased operation should be invoked.
 //
+// "dispose" specifies that the manager should perform a destroy.
+//
 // "relocate_from_to" specifies that the manager should perform a move.
 //
-// "dispose" specifies that the manager should perform a destroy.
-enum class FunctionToCall : bool { relocate_from_to, dispose };
+// "relocate_from_to_and_query_rust" is identical to "relocate_from_to" for C++
+// managers, but instructs Rust managers to perform a special operation that
+// can be detected by the caller.
+enum class FunctionToCall : unsigned char {
+  dispose,
+  relocate_from_to,
+  relocate_from_to_and_query_rust,
+};
 
 // The portion of `AnyInvocable` state that contains either a pointer to the
 // target object or the object itself in local storage
@@ -242,6 +251,7 @@ void LocalManagerNontrivial(FunctionToCall operation,
 
   switch (operation) {
     case FunctionToCall::relocate_from_to:
+    case FunctionToCall::relocate_from_to_and_query_rust:
       // NOTE: Requires that the left-hand operand is already empty.
       ::new (static_cast<void*>(&to->storage)) T(std::move(from_object));
       ABSL_FALLTHROUGH_INTENDED;
@@ -276,6 +286,7 @@ inline void RemoteManagerTrivial(FunctionToCall operation,
                                  TypeErasedState* const to) noexcept {
   switch (operation) {
     case FunctionToCall::relocate_from_to:
+    case FunctionToCall::relocate_from_to_and_query_rust:
       // NOTE: Requires that the left-hand operand is already empty.
       to->remote = from->remote;
       return;
@@ -302,6 +313,7 @@ void RemoteManagerNontrivial(FunctionToCall operation,
 
   switch (operation) {
     case FunctionToCall::relocate_from_to:
+    case FunctionToCall::relocate_from_to_and_query_rust:
       // NOTE: Requires that the left-hand operand is already empty.
       to->remote.target = from->remote.target;
       return;
@@ -330,12 +342,12 @@ ReturnType RemoteInvoker(
 ////////////////////////////////////////////////////////////////////////////////
 //
 // A metafunction that checks if a type T is an instantiation of
-// absl::in_place_type_t (needed for constructor constraints of AnyInvocable).
+// std::in_place_type_t (needed for constructor constraints of AnyInvocable).
 template <class T>
 struct IsInPlaceType : std::false_type {};
 
 template <class T>
-struct IsInPlaceType<absl::in_place_type_t<T>> : std::true_type {};
+struct IsInPlaceType<std::in_place_type_t<T>> : std::true_type {};
 //
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -452,7 +464,7 @@ class CoreImpl {
   // invocation of the Invocable. The unqualified type is the target object
   // type to be stored.
   template <class QualTRef, class... Args>
-  explicit CoreImpl(absl::in_place_type_t<QualTRef>, Args&&... args) {
+  explicit CoreImpl(std::in_place_type_t<QualTRef>, Args&&... args) {
     InitializeStorage<QualTRef>(std::forward<Args>(args)...);
   }
 
@@ -599,39 +611,39 @@ using TrueAlias =
 
 /*SFINAE constraints for the conversion-constructor.*/
 template <class Sig, class F,
-          class = absl::enable_if_t<
+          class = std::enable_if_t<
               !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
 using CanConvert = TrueAlias<
-    absl::enable_if_t<!IsInPlaceType<RemoveCVRef<F>>::value>,
-    absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
-    absl::enable_if_t<
+    std::enable_if_t<!IsInPlaceType<RemoveCVRef<F>>::value>,
+    std::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
+    std::enable_if_t<
         Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
-    absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
+    std::enable_if_t<std::is_constructible<std::decay_t<F>, F>::value>>;
 
 /*SFINAE constraints for the std::in_place constructors.*/
 template <class Sig, class F, class... Args>
 using CanEmplace = TrueAlias<
-    absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
-    absl::enable_if_t<
+    std::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
+    std::enable_if_t<
         Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
-    absl::enable_if_t<std::is_constructible<absl::decay_t<F>, Args...>::value>>;
+    std::enable_if_t<std::is_constructible<std::decay_t<F>, Args...>::value>>;
 
 /*SFINAE constraints for the conversion-assign operator.*/
 template <class Sig, class F,
-          class = absl::enable_if_t<
+          class = std::enable_if_t<
               !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
 using CanAssign = TrueAlias<
-    absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
-    absl::enable_if_t<
+    std::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
+    std::enable_if_t<
         Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
-    absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
+    std::enable_if_t<std::is_constructible<std::decay_t<F>, F>::value>>;
 
 /*SFINAE constraints for the reference-wrapper conversion-assign operator.*/
 template <class Sig, class F>
 using CanAssignReferenceWrapper = TrueAlias<
-    absl::enable_if_t<
+    std::enable_if_t<
         Impl<Sig>::template CallIsValid<std::reference_wrapper<F>>::value>,
-    absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<
+    std::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<
         std::reference_wrapper<F>>::value>>;
 
 // The constraint for checking whether or not a call meets the noexcept
@@ -645,17 +657,17 @@ using CanAssignReferenceWrapper = TrueAlias<
 // don't treat non-moveable result types correctly. For example this was the
 // case in libc++ before commit c3a24882 (2022-05).
 #define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true(inv_quals)      \
-  absl::enable_if_t<absl::disjunction<                                       \
+  std::enable_if_t<std::disjunction<                                       \
       std::is_nothrow_invocable_r<                                           \
-          ReturnType, UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, \
+          ReturnType, UnwrapStdReferenceWrapper<std::decay_t<F>> inv_quals, \
           P...>,                                                             \
       std::conjunction<                                                      \
           std::is_nothrow_invocable<                                         \
-              UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, P...>,  \
+              UnwrapStdReferenceWrapper<std::decay_t<F>> inv_quals, P...>,  \
           std::is_same<                                                      \
               ReturnType,                                                    \
               std::invoke_result_t<                                          \
-                  UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,     \
+                  UnwrapStdReferenceWrapper<std::decay_t<F>> inv_quals,     \
                   P...>>>>::value>
 
 #define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false(inv_quals)
@@ -684,11 +696,11 @@ using CanAssignReferenceWrapper = TrueAlias<
                                                                                \
     /*SFINAE constraint to check if F is invocable with the proper signature*/ \
     template <class F>                                                         \
-    using CallIsValid = TrueAlias<absl::enable_if_t<absl::disjunction<         \
-        std::is_invocable_r<ReturnType, absl::decay_t<F> inv_quals, P...>,     \
-        std::is_same<                                                          \
-            ReturnType,                                                        \
-            std::invoke_result_t<absl::decay_t<F> inv_quals, P...>>>::value>>; \
+    using CallIsValid = TrueAlias<std::enable_if_t<std::disjunction<           \
+        std::is_invocable_r<ReturnType, std::decay_t<F> inv_quals, P...>,      \
+        std::is_same<ReturnType,                                               \
+                     std::invoke_result_t<std::decay_t<F> inv_quals, P...>>>:: \
+                                                       value>>;                \
                                                                                \
     /*SFINAE constraint to check if F is nothrow-invocable when necessary*/    \
     template <class F>                                                         \
@@ -710,8 +722,8 @@ using CanAssignReferenceWrapper = TrueAlias<
                                                                                \
     /*Forward along the in-place construction parameters.*/                    \
     template <class T, class... Args>                                          \
-    explicit Impl(absl::in_place_type_t<T>, Args&&... args)                    \
-        : Core(absl::in_place_type<absl::decay_t<T> inv_quals>,                \
+    explicit Impl(std::in_place_type_t<T>, Args&&... args)                     \
+        : Core(std::in_place_type<std::decay_t<T> inv_quals>,                  \
                std::forward<Args>(args)...) {}                                 \
                                                                                \
     /*Raises a fatal error when the AnyInvocable is invoked after a move*/     \

data/third_party/abseil-cpp/absl/functional/internal/front_binder.h

@@ -31,7 +31,7 @@ namespace functional_internal {
 
 // Invoke the method, expanding the tuple of bound arguments.
 template <class R, class Tuple, size_t... Idx, class... Args>
-R Apply(Tuple&& bound, absl::index_sequence<Idx...>, Args&&... free) {
+R Apply(Tuple&& bound, std::index_sequence<Idx...>, Args&&... free) {
   return std::invoke(std::forward<Tuple>(bound).template get<Idx>()...,
                      std::forward<Args>(free)...);
 }
@@ -39,13 +39,13 @@ R Apply(Tuple&& bound, absl::index_sequence<Idx...>, Args&&... free) {
 template <class F, class... BoundArgs>
 class FrontBinder {
   using BoundArgsT = absl::container_internal::CompressedTuple<F, BoundArgs...>;
-  using Idx = absl::make_index_sequence<sizeof...(BoundArgs) + 1>;
+  using Idx = std::make_index_sequence<sizeof...(BoundArgs) + 1>;
 
   BoundArgsT bound_args_;
 
  public:
   template <class... Ts>
-  constexpr explicit FrontBinder(absl::in_place_t, Ts&&... ts)
+  constexpr explicit FrontBinder(std::in_place_t, Ts&&... ts)
       : bound_args_(std::forward<Ts>(ts)...) {}
 
   template <class... FreeArgs,
@@ -84,7 +84,7 @@ class FrontBinder {
 };
 
 template <class F, class... BoundArgs>
-using bind_front_t = FrontBinder<decay_t<F>, absl::decay_t<BoundArgs>...>;
+using bind_front_t = FrontBinder<std::decay_t<F>, std::decay_t<BoundArgs>...>;
 
 }  // namespace functional_internal
 ABSL_NAMESPACE_END

data/third_party/abseil-cpp/absl/functional/internal/function_ref.h

@@ -47,8 +47,8 @@ struct PassByValue : std::false_type {};
 template <typename T>
 struct PassByValue<T, /*IsLValueReference=*/false>
     : std::integral_constant<bool,
-                             absl::is_trivially_copy_constructible<T>::value &&
-                                 absl::is_trivially_copy_assignable<
+                             std::is_trivially_copy_constructible<T>::value &&
+                                 std::is_trivially_copy_assignable<
                                      typename std::remove_cv<T>::type>::value &&
                                  std::is_trivially_destructible<T>::value &&
                                  sizeof(T) <= 2 * sizeof(void*)> {};
@@ -72,14 +72,52 @@ using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);
 // static_cast<R> handles the case the return type is void.
 template <typename Obj, typename R, typename... Args>
 R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
-  auto o = static_cast<const Obj*>(ptr.obj);
-  return static_cast<R>(std::invoke(*o, std::forward<Args>(args)...));
+  using T = std::remove_reference_t<Obj>;
+  return static_cast<R>(std::invoke(
+      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
+      std::forward<typename ForwardT<Args>::type>(args)...));
+}
+
+template <typename Obj, typename Fun, Fun F, typename R, typename... Args>
+R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
+  using T = std::remove_reference_t<Obj>;
+  Obj&& obj =
+      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj)));
+  // Avoid std::invoke() since the callee is a known function at compile time
+  if constexpr (std::is_member_function_pointer_v<Fun>) {
+    return static_cast<R>((std::forward<Obj>(obj).*F)(
+        std::forward<typename ForwardT<Args>::type>(args)...));
+  } else {
+    return static_cast<R>(
+        F(std::forward<Obj>(obj),
+          std::forward<typename ForwardT<Args>::type>(args)...));
+  }
+}
+
+template <typename T, typename Fun, Fun F, typename R, typename... Args>
+R InvokePtr(VoidPtr ptr, typename ForwardT<Args>::type... args) {
+  T* obj = const_cast<T*>(static_cast<const T*>(ptr.obj));
+  // Avoid std::invoke() since the callee is a known function at compile time
+  if constexpr (std::is_member_function_pointer_v<Fun>) {
+    return static_cast<R>(
+        (obj->*F)(std::forward<typename ForwardT<Args>::type>(args)...));
+  } else {
+    return static_cast<R>(
+        F(obj, std::forward<typename ForwardT<Args>::type>(args)...));
+  }
 }
 
 template <typename Fun, typename R, typename... Args>
 R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   auto f = reinterpret_cast<Fun>(ptr.fun);
-  return static_cast<R>(std::invoke(f, std::forward<Args>(args)...));
+  return static_cast<R>(
+      std::invoke(f, std::forward<typename ForwardT<Args>::type>(args)...));
+}
+
+template <typename Fun, Fun F, typename R, typename... Args>
+R InvokeFunction(VoidPtr, typename ForwardT<Args>::type... args) {
+  return static_cast<R>(
+      F(std::forward<typename ForwardT<Args>::type>(args)...));
 }
 
 template <typename Sig>
@@ -98,7 +136,7 @@ template <typename F>
 void AssertNonNull(const F&) {}
 
 template <typename F, typename C>
-void AssertNonNull(F C::*f) {
+void AssertNonNull(F C::* f) {
   assert(f != nullptr);
   (void)f;
 }

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

@@ -329,7 +329,7 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   // users should not define their own HashState types.
   template <
       typename T,
-      absl::enable_if_t<
+      std::enable_if_t<
           std::is_base_of<hash_internal::HashStateBase<T>, T>::value, int> = 0>
   static HashState Create(T* state) {
     HashState s;