THUAI6/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h

// Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Implementation details for `absl::AnyInvocable`

#ifndef ABSL_FUNCTIONAL_INTERNAL_ANY_INVOCABLE_H_
#define ABSL_FUNCTIONAL_INTERNAL_ANY_INVOCABLE_H_

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// This implementation of the proposed `any_invocable` uses an approach that  //
// chooses between local storage and remote storage for the contained target  //
// object based on the target object's size, alignment requirements, and      //
// whether or not it has a nothrow move constructor. Additional optimizations //
// are performed when the object is a trivially copyable type [basic.types].  //
//                                                                            //
// There are three datamembers per `AnyInvocable` instance                    //
//                                                                            //
// 1) A union containing either                                               //
//        - A pointer to the target object referred to via a void*, or        //
//        - the target object, emplaced into a raw char buffer                //
//                                                                            //
// 2) A function pointer to a "manager" function operation that takes a       //
//    discriminator and logically branches to either perform a move operation //
//    or destroy operation based on that discriminator.                       //
//                                                                            //
// 3) A function pointer to an "invoker" function operation that invokes the  //
//    target object, directly returning the result.                           //
//                                                                            //
// When in the logically empty state, the manager function is an empty        //
// function and the invoker function is one that would be undefined-behavior  //
// to call.                                                                   //
//                                                                            //
// An additional optimization is performed when converting from one           //
// AnyInvocable to another where only the noexcept specification and/or the   //
// cv/ref qualifiers of the function type differ. In these cases, the         //
// conversion works by "moving the guts", similar to if they were the same    //
// exact type, as opposed to having to perform an additional layer of         //
// wrapping through remote storage.                                           //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

// IWYU pragma: private, include "absl/functional/any_invocable.h"

#include <cassert>
#include <cstddef>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>

#include "absl/base/config.h"
#include "absl/base/internal/invoke.h"
#include "absl/base/macros.h"
#include "absl/meta/type_traits.h"
#include "absl/utility/utility.h"

namespace absl
{
    ABSL_NAMESPACE_BEGIN

// Helper macro used to prevent spelling `noexcept` in language versions older
// than C++17, where it is not part of the type system, in order to avoid
// compilation failures and internal compiler errors.
#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
#define ABSL_INTERNAL_NOEXCEPT_SPEC(noex) noexcept(noex)
#else
#define ABSL_INTERNAL_NOEXCEPT_SPEC(noex)
#endif

    // Defined in functional/any_invocable.h
    template<class Sig>
    class AnyInvocable;

    namespace internal_any_invocable
    {

        // Constants relating to the small-object-storage for AnyInvocable
        enum StorageProperty : std::size_t
        {
            kAlignment = alignof(std::max_align_t),  // The alignment of the storage
            kStorageSize = sizeof(void*) * 2         // The size of the storage
        };

        ////////////////////////////////////////////////////////////////////////////////
        //
        // A metafunction for checking if a type is an AnyInvocable instantiation.
        // This is used during conversion operations.
        template<class T>
        struct IsAnyInvocable : std::false_type
        {
        };

        template<class Sig>
        struct IsAnyInvocable<AnyInvocable<Sig>> : std::true_type
        {
        };
        //
        ////////////////////////////////////////////////////////////////////////////////

        // A type trait that tells us whether or not a target function type should be
        // stored locally in the small object optimization storage
        template<class T>
        using IsStoredLocally = std::integral_constant<
            bool,
            sizeof(T) <= kStorageSize && alignof(T) <= kAlignment &&
                kAlignment % alignof(T) == 0 &&
                std::is_nothrow_move_constructible<T>::value>;

        // An implementation of std::remove_cvref_t of C++20.
        template<class T>
        using RemoveCVRef =
            typename std::remove_cv<typename std::remove_reference<T>::type>::type;

        ////////////////////////////////////////////////////////////////////////////////
        //
        // An implementation of the C++ standard INVOKE<R> pseudo-macro, operation is
        // equivalent to std::invoke except that it forces an implicit conversion to the
        // specified return type. If "R" is void, the function is executed and the
        // return value is simply ignored.
        template<class ReturnType, class F, class... P, typename = absl::enable_if_t<std::is_void<ReturnType>::value>>
        void InvokeR(F&& f, P&&... args)
        {
            absl::base_internal::invoke(std::forward<F>(f), std::forward<P>(args)...);
        }

        template<class ReturnType, class F, class... P, absl::enable_if_t<!std::is_void<ReturnType>::value, int> = 0>
        ReturnType InvokeR(F&& f, P&&... args)
        {
            return absl::base_internal::invoke(std::forward<F>(f), std::forward<P>(args)...);
        }

        //
        ////////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////////
        ///
        // A metafunction that takes a "T" corresponding to a parameter type of the
        // user's specified function type, and yields the parameter type to use for the
        // type-erased invoker. In order to prevent observable moves, this must be
        // either a reference or, if the type is trivial, the original parameter type
        // itself. Since the parameter type may be incomplete at the point that this
        // metafunction is used, we can only do this optimization for scalar types
        // rather than for any trivial type.
        template<typename T>
        T ForwardImpl(std::true_type);

        template<typename T>
        T&& ForwardImpl(std::false_type);

        // NOTE: We deliberately use an intermediate struct instead of a direct alias,
        // as a workaround for b/206991861 on MSVC versions < 1924.
        template<class T>
        struct ForwardedParameter
        {
            using type = decltype((
                ForwardImpl<T>
            )(std::integral_constant<bool, std::is_scalar<T>::value>()));
        };

        template<class T>
        using ForwardedParameterType = typename ForwardedParameter<T>::type;
        //
        ////////////////////////////////////////////////////////////////////////////////

        // A discriminator when calling the "manager" function that describes operation
        // type-erased operation should be invoked.
        //
        // "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
        };

        // The portion of `AnyInvocable` state that contains either a pointer to the
        // target object or the object itself in local storage
        union TypeErasedState
        {
            struct
            {
                // A pointer to the type-erased object when remotely stored
                void* target;
                // The size of the object for `RemoteManagerTrivial`
                std::size_t size;
            } remote;

            // Local-storage for the type-erased object when small and trivial enough
            alignas(kAlignment) char storage[kStorageSize];
        };

        // A typed accessor for the object in `TypeErasedState` storage
        template<class T>
        T& ObjectInLocalStorage(TypeErasedState* const state)
        {
            // We launder here because the storage may be reused with the same type.
#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
            return *std::launder(reinterpret_cast<T*>(&state->storage));
#elif ABSL_HAVE_BUILTIN(__builtin_launder)
            return *__builtin_launder(reinterpret_cast<T*>(&state->storage));
#else

            // When `std::launder` or equivalent are not available, we rely on undefined
            // behavior, which works as intended on Abseil's officially supported
            // platforms as of Q2 2022.
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#pragma GCC diagnostic push
#endif
            return *reinterpret_cast<T*>(&state->storage);
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif

#endif
        }

        // The type for functions issuing lifetime-related operations: move and dispose
        // A pointer to such a function is contained in each `AnyInvocable` instance.
        // NOTE: When specifying `FunctionToCall::`dispose, the same state must be
        // passed as both "from" and "to".
        using ManagerType = void(FunctionToCall /*operation*/, TypeErasedState* /*from*/, TypeErasedState* /*to*/)
            ABSL_INTERNAL_NOEXCEPT_SPEC(true);

        // The type for functions issuing the actual invocation of the object
        // A pointer to such a function is contained in each AnyInvocable instance.
        template<bool SigIsNoexcept, class ReturnType, class... P>
        using InvokerType = ReturnType(TypeErasedState*, ForwardedParameterType<P>...)
            ABSL_INTERNAL_NOEXCEPT_SPEC(SigIsNoexcept);

        // The manager that is used when AnyInvocable is empty
        inline void EmptyManager(FunctionToCall /*operation*/, TypeErasedState* /*from*/, TypeErasedState* /*to*/) noexcept
        {
        }

        // The manager that is used when a target function is in local storage and is
        // a trivially copyable type.
        inline void LocalManagerTrivial(FunctionToCall /*operation*/, TypeErasedState* const from, TypeErasedState* const to) noexcept
        {
            // This single statement without branching handles both possible operations.
            //
            // For FunctionToCall::dispose, "from" and "to" point to the same state, and
            // so this assignment logically would do nothing.
            //
            // Note: Correctness here relies on http://wg21.link/p0593, which has only
            // become standard in C++20, though implementations do not break it in
            // practice for earlier versions of C++.
            //
            // The correct way to do this without that paper is to first placement-new a
            // default-constructed T in "to->storage" prior to the memmove, but doing so
            // requires a different function to be created for each T that is stored
            // locally, which can cause unnecessary bloat and be less cache friendly.
            *to = *from;

            // Note: Because the type is trivially copyable, the destructor does not need
            // to be called ("trivially copyable" requires a trivial destructor).
        }

        // The manager that is used when a target function is in local storage and is
        // not a trivially copyable type.
        template<class T>
        void LocalManagerNontrivial(FunctionToCall operation, TypeErasedState* const from, TypeErasedState* const to) noexcept
        {
            static_assert(IsStoredLocally<T>::value, "Local storage must only be used for supported types.");
            static_assert(!std::is_trivially_copyable<T>::value, "Locally stored types must be trivially copyable.");

            T& from_object = (ObjectInLocalStorage<T>)(from);

            switch (operation)
            {
                case FunctionToCall::relocate_from_to:
                    // NOTE: Requires that the left-hand operand is already empty.
                    ::new (static_cast<void*>(&to->storage)) T(std::move(from_object));
                    ABSL_FALLTHROUGH_INTENDED;
                case FunctionToCall::dispose:
                    from_object.~T();  // Must not throw. // NOLINT
                    return;
            }
            ABSL_INTERNAL_UNREACHABLE;
        }

        // The invoker that is used when a target function is in local storage
        // Note: QualTRef here is the target function type along with cv and reference
        // qualifiers that must be used when calling the function.
        template<bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
        ReturnType LocalInvoker(
            TypeErasedState* const state,
            ForwardedParameterType<P>... args
        ) noexcept(SigIsNoexcept)
        {
            using RawT = RemoveCVRef<QualTRef>;
            static_assert(
                IsStoredLocally<RawT>::value,
                "Target object must be in local storage in order to be invoked from it."
            );

            auto& f = (ObjectInLocalStorage<RawT>)(state);
            return (InvokeR<ReturnType>)(static_cast<QualTRef>(f), static_cast<ForwardedParameterType<P>>(args)...);
        }

        // The manager that is used when a target function is in remote storage and it
        // has a trivial destructor
        inline void RemoteManagerTrivial(FunctionToCall operation, TypeErasedState* const from, TypeErasedState* const to) noexcept
        {
            switch (operation)
            {
                case FunctionToCall::relocate_from_to:
                    // NOTE: Requires that the left-hand operand is already empty.
                    to->remote = from->remote;
                    return;
                case FunctionToCall::dispose:
#if defined(__cpp_sized_deallocation)
                    ::operator delete(from->remote.target, from->remote.size);
#else   // __cpp_sized_deallocation
                    ::operator delete(from->remote.target);
#endif  // __cpp_sized_deallocation
                    return;
            }
            ABSL_INTERNAL_UNREACHABLE;
        }

        // The manager that is used when a target function is in remote storage and the
        // destructor of the type is not trivial
        template<class T>
        void RemoteManagerNontrivial(FunctionToCall operation, TypeErasedState* const from, TypeErasedState* const to) noexcept
        {
            static_assert(!IsStoredLocally<T>::value, "Remote storage must only be used for types that do not "
                                                      "qualify for local storage.");

            switch (operation)
            {
                case FunctionToCall::relocate_from_to:
                    // NOTE: Requires that the left-hand operand is already empty.
                    to->remote.target = from->remote.target;
                    return;
                case FunctionToCall::dispose:
                    ::delete static_cast<T*>(from->remote.target);  // Must not throw.
                    return;
            }
            ABSL_INTERNAL_UNREACHABLE;
        }

        // The invoker that is used when a target function is in remote storage
        template<bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
        ReturnType RemoteInvoker(
            TypeErasedState* const state,
            ForwardedParameterType<P>... args
        ) noexcept(SigIsNoexcept)
        {
            using RawT = RemoveCVRef<QualTRef>;
            static_assert(!IsStoredLocally<RawT>::value, "Target object must be in remote storage in order to be "
                                                         "invoked from it.");

            auto& f = *static_cast<RawT*>(state->remote.target);
            return (InvokeR<ReturnType>)(static_cast<QualTRef>(f), static_cast<ForwardedParameterType<P>>(args)...);
        }

        ////////////////////////////////////////////////////////////////////////////////
        //
        // A metafunction that checks if a type T is an instantiation of
        // absl::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
        {
        };
        //
        ////////////////////////////////////////////////////////////////////////////////

        // A constructor name-tag used with CoreImpl (below) to request the
        // conversion-constructor. QualDecayedTRef is the decayed-type of the object to
        // wrap, along with the cv and reference qualifiers that must be applied when
        // performing an invocation of the wrapped object.
        template<class QualDecayedTRef>
        struct TypedConversionConstruct
        {
        };

        // A helper base class for all core operations of AnyInvocable. Most notably,
        // this class creates the function call operator and constraint-checkers so that
        // the top-level class does not have to be a series of partial specializations.
        //
        // Note: This definition exists (as opposed to being a declaration) so that if
        // the user of the top-level template accidentally passes a template argument
        // that is not a function type, they will get a static_assert in AnyInvocable's
        // class body rather than an error stating that Impl is not defined.
        template<class Sig>
        class Impl
        {
        };  // Note: This is partially-specialized later.

// A std::unique_ptr deleter that deletes memory allocated via ::operator new.
#if defined(__cpp_sized_deallocation)
        class TrivialDeleter
        {
        public:
            explicit TrivialDeleter(std::size_t size) :
                size_(size)
            {
            }

            void operator()(void* target) const
            {
                ::operator delete(target, size_);
            }

        private:
            std::size_t size_;
        };
#else   // __cpp_sized_deallocation
        class TrivialDeleter
        {
        public:
            explicit TrivialDeleter(std::size_t)
            {
            }

            void operator()(void* target) const
            {
                ::operator delete(target);
            }
        };
#endif  // __cpp_sized_deallocation

        template<bool SigIsNoexcept, class ReturnType, class... P>
        class CoreImpl;

        constexpr bool IsCompatibleConversion(void*, void*)
        {
            return false;
        }
        template<bool NoExceptSrc, bool NoExceptDest, class... T>
        constexpr bool IsCompatibleConversion(CoreImpl<NoExceptSrc, T...>*, CoreImpl<NoExceptDest, T...>*)
        {
            return !NoExceptDest || NoExceptSrc;
        }

        // A helper base class for all core operations of AnyInvocable that do not
        // depend on the cv/ref qualifiers of the function type.
        template<bool SigIsNoexcept, class ReturnType, class... P>
        class CoreImpl
        {
        public:
            using result_type = ReturnType;

            CoreImpl() noexcept :
                manager_(EmptyManager),
                invoker_(nullptr)
            {
            }

            enum class TargetType : int
            {
                kPointer = 0,
                kCompatibleAnyInvocable = 1,
                kIncompatibleAnyInvocable = 2,
                kOther = 3,
            };

            // Note: QualDecayedTRef here includes the cv-ref qualifiers associated with
            // the invocation of the Invocable. The unqualified type is the target object
            // type to be stored.
            template<class QualDecayedTRef, class F>
            explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f)
            {
                using DecayedT = RemoveCVRef<QualDecayedTRef>;

                constexpr TargetType kTargetType =
                    (std::is_pointer<DecayedT>::value ||
                     std::is_member_pointer<DecayedT>::value) ?
                        TargetType::kPointer :
                    IsCompatibleAnyInvocable<DecayedT>::value ? TargetType::kCompatibleAnyInvocable :
                    IsAnyInvocable<DecayedT>::value           ? TargetType::kIncompatibleAnyInvocable :
                                                                TargetType::kOther;
                // NOTE: We only use integers instead of enums as template parameters in
                // order to work around a bug on C++14 under MSVC 2017.
                // See b/236131881.
                Initialize<static_cast<int>(kTargetType), QualDecayedTRef>(
                    std::forward<F>(f)
                );
            }

            // Note: QualTRef here includes the cv-ref qualifiers associated with the
            // 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)
            {
                InitializeStorage<QualTRef>(std::forward<Args>(args)...);
            }

            CoreImpl(CoreImpl&& other) noexcept
            {
                other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
                manager_ = other.manager_;
                invoker_ = other.invoker_;
                other.manager_ = EmptyManager;
                other.invoker_ = nullptr;
            }

            CoreImpl& operator=(CoreImpl&& other) noexcept
            {
                // Put the left-hand operand in an empty state.
                //
                // Note: A full reset that leaves us with an object that has its invariants
                // intact is necessary in order to handle self-move. This is required by
                // types that are used with certain operations of the standard library, such
                // as the default definition of std::swap when both operands target the same
                // object.
                Clear();

                // Perform the actual move/destory operation on the target function.
                other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
                manager_ = other.manager_;
                invoker_ = other.invoker_;
                other.manager_ = EmptyManager;
                other.invoker_ = nullptr;

                return *this;
            }

            ~CoreImpl()
            {
                manager_(FunctionToCall::dispose, &state_, &state_);
            }

            // Check whether or not the AnyInvocable is in the empty state.
            bool HasValue() const
            {
                return invoker_ != nullptr;
            }

            // Effects: Puts the object into its empty state.
            void Clear()
            {
                manager_(FunctionToCall::dispose, &state_, &state_);
                manager_ = EmptyManager;
                invoker_ = nullptr;
            }

            template<int target_type, class QualDecayedTRef, class F, absl::enable_if_t<target_type == 0, int> = 0>
            void Initialize(F&& f)
            {
// This condition handles types that decay into pointers, which includes
// function references. Since function references cannot be null, GCC warns
// against comparing their decayed form with nullptr.
// Since this is template-heavy code, we prefer to disable these warnings
// locally instead of adding yet another overload of this function.
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Waddress"
#pragma GCC diagnostic ignored "-Wnonnull-compare"
#pragma GCC diagnostic push
#endif
                if (static_cast<RemoveCVRef<QualDecayedTRef>>(f) == nullptr)
                {
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                    manager_ = EmptyManager;
                    invoker_ = nullptr;
                    return;
                }
                InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
            }

            template<int target_type, class QualDecayedTRef, class F, absl::enable_if_t<target_type == 1, int> = 0>
            void Initialize(F&& f)
            {
                // In this case we can "steal the guts" of the other AnyInvocable.
                f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
                manager_ = f.manager_;
                invoker_ = f.invoker_;

                f.manager_ = EmptyManager;
                f.invoker_ = nullptr;
            }

            template<int target_type, class QualDecayedTRef, class F, absl::enable_if_t<target_type == 2, int> = 0>
            void Initialize(F&& f)
            {
                if (f.HasValue())
                {
                    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
                }
                else
                {
                    manager_ = EmptyManager;
                    invoker_ = nullptr;
                }
            }

            template<int target_type, class QualDecayedTRef, class F, typename = absl::enable_if_t<target_type == 3>>
            void Initialize(F&& f)
            {
                InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
            }

            // Use local (inline) storage for applicable target object types.
            template<class QualTRef, class... Args, typename = absl::enable_if_t<IsStoredLocally<RemoveCVRef<QualTRef>>::value>>
            void InitializeStorage(Args&&... args)
            {
                using RawT = RemoveCVRef<QualTRef>;
                ::new (static_cast<void*>(&state_.storage))
                    RawT(std::forward<Args>(args)...);

                invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
                // We can simplify our manager if we know the type is trivially copyable.
                InitializeLocalManager<RawT>();
            }

            // Use remote storage for target objects that cannot be stored locally.
            template<class QualTRef, class... Args, absl::enable_if_t<!IsStoredLocally<RemoveCVRef<QualTRef>>::value, int> = 0>
            void InitializeStorage(Args&&... args)
            {
                InitializeRemoteManager<RemoveCVRef<QualTRef>>(std::forward<Args>(args)...);
                // This is set after everything else in case an exception is thrown in an
                // earlier step of the initialization.
                invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
            }

            template<class T, typename = absl::enable_if_t<std::is_trivially_copyable<T>::value>>
            void InitializeLocalManager()
            {
                manager_ = LocalManagerTrivial;
            }

            template<class T, absl::enable_if_t<!std::is_trivially_copyable<T>::value, int> = 0>
            void InitializeLocalManager()
            {
                manager_ = LocalManagerNontrivial<T>;
            }

            template<class T>
            using HasTrivialRemoteStorage =
                std::integral_constant<bool, std::is_trivially_destructible<T>::value && alignof(T) <= ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT>;

            template<class T, class... Args, typename = absl::enable_if_t<HasTrivialRemoteStorage<T>::value>>
            void InitializeRemoteManager(Args&&... args)
            {
                // unique_ptr is used for exception-safety in case construction throws.
                std::unique_ptr<void, TrivialDeleter> uninitialized_target(
                    ::operator new(sizeof(T)), TrivialDeleter(sizeof(T))
                );
                ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
                state_.remote.target = uninitialized_target.release();
                state_.remote.size = sizeof(T);
                manager_ = RemoteManagerTrivial;
            }

            template<class T, class... Args, absl::enable_if_t<!HasTrivialRemoteStorage<T>::value, int> = 0>
            void InitializeRemoteManager(Args&&... args)
            {
                state_.remote.target = ::new T(std::forward<Args>(args)...);
                manager_ = RemoteManagerNontrivial<T>;
            }

            //////////////////////////////////////////////////////////////////////////////
            //
            // Type trait to determine if the template argument is an AnyInvocable whose
            // function type is compatible enough with ours such that we can
            // "move the guts" out of it when moving, rather than having to place a new
            // object into remote storage.

            template<typename Other>
            struct IsCompatibleAnyInvocable
            {
                static constexpr bool value = false;
            };

            template<typename Sig>
            struct IsCompatibleAnyInvocable<AnyInvocable<Sig>>
            {
                static constexpr bool value =
                    (IsCompatibleConversion)(static_cast<typename AnyInvocable<Sig>::CoreImpl*>(nullptr), static_cast<CoreImpl*>(nullptr));
            };

            //
            //////////////////////////////////////////////////////////////////////////////

            TypeErasedState state_;
            ManagerType* manager_;
            InvokerType<SigIsNoexcept, ReturnType, P...>* invoker_;
        };

        // A constructor name-tag used with Impl to request the
        // conversion-constructor
        struct ConversionConstruct
        {
        };

        ////////////////////////////////////////////////////////////////////////////////
        //
        // A metafunction that is normally an identity metafunction except that when
        // given a std::reference_wrapper<T>, it yields T&. This is necessary because
        // currently std::reference_wrapper's operator() is not conditionally noexcept,
        // so when checking if such an Invocable is nothrow-invocable, we must pull out
        // the underlying type.
        template<class T>
        struct UnwrapStdReferenceWrapperImpl
        {
            using type = T;
        };

        template<class T>
        struct UnwrapStdReferenceWrapperImpl<std::reference_wrapper<T>>
        {
            using type = T&;
        };

        template<class T>
        using UnwrapStdReferenceWrapper =
            typename UnwrapStdReferenceWrapperImpl<T>::type;
        //
        ////////////////////////////////////////////////////////////////////////////////

        // An alias that always yields std::true_type (used with constraints) where
        // substitution failures happen when forming the template arguments.
        template<class... T>
        using True =
            std::integral_constant<bool, sizeof(absl::void_t<T...>*) != 0>;

        /*SFINAE constraints for the conversion-constructor.*/
        template<class Sig, class F, class = absl::enable_if_t<!std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
        using CanConvert =
            True<absl::enable_if_t<!IsInPlaceType<RemoveCVRef<F>>::value>, absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>, absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>, absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;

        /*SFINAE constraints for the std::in_place constructors.*/
        template<class Sig, class F, class... Args>
        using CanEmplace = True<
            absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
            absl::enable_if_t<
                Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
            absl::enable_if_t<std::is_constructible<absl::decay_t<F>, Args...>::value>>;

        /*SFINAE constraints for the conversion-assign operator.*/
        template<class Sig, class F, class = absl::enable_if_t<!std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
        using CanAssign =
            True<absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>, absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>, absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;

        /*SFINAE constraints for the reference-wrapper conversion-assign operator.*/
        template<class Sig, class F>
        using CanAssignReferenceWrapper =
            True<absl::enable_if_t<Impl<Sig>::template CallIsValid<std::reference_wrapper<F>>::value>, absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<std::reference_wrapper<F>>::value>>;

////////////////////////////////////////////////////////////////////////////////
//
// The constraint for checking whether or not a call meets the noexcept
// callability requirements. This is a preprocessor macro because specifying it
// this way as opposed to a disjunction/branch can improve the user-side error
// messages and avoids an instantiation of std::is_nothrow_invocable_r in the
// cases where the user did not specify a noexcept function type.
//
#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals, noex) \
    ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_##noex(inv_quals)

// The disjunction below is because we can't rely on std::is_nothrow_invocable_r
// to give the right result when ReturnType is non-moveable in toolchains that
// 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::is_nothrow_invocable_r<                                       \
            ReturnType,                                                    \
            UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,         \
            P...>,                                                         \
        std::conjunction<                                                  \
            std::is_nothrow_invocable<                                     \
                UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,     \
                P...>,                                                     \
            std::is_same<                                                  \
                ReturnType,                                                \
                absl::base_internal::invoke_result_t<                      \
                    UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, \
                    P...>>>>::value>

#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false(inv_quals)
//
////////////////////////////////////////////////////////////////////////////////

// A macro to generate partial specializations of Impl with the different
// combinations of supported cv/reference qualifiers and noexcept specifier.
//
// Here, `cv` are the cv-qualifiers if any, `ref` is the ref-qualifier if any,
// inv_quals is the reference type to be used when invoking the target, and
// noex is "true" if the function type is noexcept, or false if it is not.
//
// The CallIsValid condition is more complicated than simply using
// absl::base_internal::is_invocable_r because we can't rely on it to give the
// right result when ReturnType is non-moveable in toolchains that 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_IMPL_(cv, ref, inv_quals, noex)                                                                                  \
    template<class ReturnType, class... P>                                                                                                           \
    class Impl<ReturnType(P...) cv ref ABSL_INTERNAL_NOEXCEPT_SPEC(noex)> : public CoreImpl<noex, ReturnType, P...>                                  \
    {                                                                                                                                                \
    public:                                                                                                                                          \
        /*The base class, which contains the datamembers and core operations*/                                                                       \
        using Core = CoreImpl<noex, ReturnType, P...>;                                                                                               \
                                                                                                                                                     \
        /*SFINAE constraint to check if F is invocable with the proper signature*/                                                                   \
        template<class F>                                                                                                                            \
        using CallIsValid = True<absl::enable_if_t<absl::disjunction<                                                                                \
            absl::base_internal::is_invocable_r<ReturnType, absl::decay_t<F> inv_quals, P...>,                                                       \
            std::is_same<ReturnType, absl::base_internal::invoke_result_t<absl::decay_t<F> inv_quals, P...>>>::value>>;                              \
                                                                                                                                                     \
        /*SFINAE constraint to check if F is nothrow-invocable when necessary*/                                                                      \
        template<class F>                                                                                                                            \
        using CallIsNoexceptIfSigIsNoexcept =                                                                                                        \
            True<ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals, noex)>;                                                                  \
                                                                                                                                                     \
        /*Put the AnyInvocable into an empty state.*/                                                                                                \
        Impl() = default;                                                                                                                            \
                                                                                                                                                     \
        /*The implementation of a conversion-constructor from "f*/                                                                                   \
        /*This forwards to Core, attaching inv_quals so that the base class*/                                                                        \
        /*knows how to properly type-erase the invocation.*/                                                                                         \
        template<class F>                                                                                                                            \
        explicit Impl(ConversionConstruct, F&& f) : Core(TypedConversionConstruct<typename std::decay<F>::type inv_quals>(), std::forward<F>(f))     \
        {                                                                                                                                            \
        }                                                                                                                                            \
                                                                                                                                                     \
        /*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>, std::forward<Args>(args)...) \
        {                                                                                                                                            \
        }                                                                                                                                            \
                                                                                                                                                     \
        /*The actual invocation operation with the proper signature*/                                                                                \
        ReturnType operator()(P... args) cv ref noexcept(noex)                                                                                       \
        {                                                                                                                                            \
            assert(this->invoker_ != nullptr);                                                                                                       \
            return this->invoker_(const_cast<TypeErasedState*>(&this->state_), static_cast<ForwardedParameterType<P>>(args)...);                     \
        }                                                                                                                                            \
    }

// Define the `noexcept(true)` specialization only for C++17 and beyond, when
// `noexcept` is part of the type system.
#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
// A convenience macro that defines specializations for the noexcept(true) and
// noexcept(false) forms, given the other properties.
#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals)      \
    ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false); \
    ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, true)
#else
#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals) \
    ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false)
#endif

        // Non-ref-qualified partial specializations
        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, , &);
        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, , const&);

        // Lvalue-ref-qualified partial specializations
        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &, &);
        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &, const&);

        // Rvalue-ref-qualified partial specializations
        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &&, &&);
        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &&, const&&);

// Undef the detail-only macros.
#undef ABSL_INTERNAL_ANY_INVOCABLE_IMPL
#undef ABSL_INTERNAL_ANY_INVOCABLE_IMPL_
#undef ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false
#undef ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true
#undef ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT
#undef ABSL_INTERNAL_NOEXCEPT_SPEC

    }  // namespace internal_any_invocable
    ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_FUNCTIONAL_INTERNAL_ANY_INVOCABLE_H_