// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BASE_FUNCTIONAL_BIND_INTERNAL_H_
#define BASE_FUNCTIONAL_BIND_INTERNAL_H_

#include <stddef.h>

#include <concepts>
#include <functional>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>

#include "base/allocator/partition_allocator/src/partition_alloc/partition_alloc_buildflags.h"
#include "base/allocator/partition_allocator/src/partition_alloc/partition_alloc_config.h"
#include "base/check.h"
#include "base/compiler_specific.h"
#include "base/functional/callback_internal.h"
#include "base/functional/unretained_traits.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/raw_ptr_asan_bound_arg_tracker.h"
#include "base/memory/raw_ref.h"
#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
#include "base/memory/weak_ptr.h"
#include "base/notreached.h"
#include "base/types/always_false.h"
#include "base/types/is_instantiation.h"
#include "build/build_config.h"
#include "base/types/to_address.h"
#include "third_party/abseil-cpp/absl/functional/function_ref.h"

// See docs/callback.md for user documentation.
//
// Concepts:
//  Functor -- A movable type representing something that should be called.
//             All function pointers and `Callback<>` are functors even if the
//             invocation syntax differs.
//  RunType -- A function type (as opposed to function _pointer_ type) for
//             a `Callback<>::Run()`.  Usually just a convenience typedef.
//  (Bound)Args -- A set of types that stores the arguments.
//
// Types:
//  `ForceVoidReturn<>` -- Helper class for translating function signatures to
//                         equivalent forms with a `void` return type.
//  `FunctorTraits<>` -- Type traits used to determine the correct RunType and
//                       invocation manner for a Functor.  This is where
//                       function signature adapters are applied.
//  `StorageTraits<>` -- Type traits that determine how a bound argument is
//                       stored in `BindState<>`.
//  `InvokeHelper<>` -- Takes a Functor + arguments and actually invokes it.
//                      Handles the differing syntaxes needed for `WeakPtr<>`
//                      support.  This is separate from `Invoker<>` to avoid
//                      creating multiple versions of `Invoker<>`.
//  `Invoker<>` -- Unwraps the curried parameters and executes the Functor.
//  `BindState<>` -- Stores the curried parameters, and is the main entry point
//                   into the `Bind()` system.

#if BUILDFLAG(IS_WIN)
namespace Microsoft {
namespace WRL {
template <typename>
class ComPtr;
}  // namespace WRL
}  // namespace Microsoft
#endif

namespace base {

template <typename T>
struct IsWeakReceiver;

template <typename>
struct BindUnwrapTraits;

template <typename Functor, typename BoundArgsTuple>
struct CallbackCancellationTraits;

template <typename Signature>
class FunctionRef;

// A tag type to return when `Bind()` calls fail. In this case we intentionally
// don't return `void`, since that would produce spurious errors like "variable
// has incomplete type 'void'" when assigning the result of
// `Bind{Once,Repeating}()` to an `auto`.
struct BindFailedCheckPreviousErrors {};

namespace unretained_traits {

// `UnretainedWrapper` will check and report if pointer is dangling upon
// invocation.
struct MayNotDangle {};
// `UnretainedWrapper` won't check if pointer is dangling upon invocation. For
// extra safety, the receiver must be of type `MayBeDangling<>`.
struct MayDangle {};
// `UnretainedWrapper` won't check if pointer is dangling upon invocation. The
// receiver doesn't have to be a `raw_ptr<>`. This is just a temporary state, to
// allow dangling pointers that would otherwise crash if `MayNotDangle` was
// used. It should be replaced ASAP with `MayNotDangle` (after fixing the
// dangling pointers) or with `MayDangle` if there is really no other way (after
// making receivers `MayBeDangling<>`).
struct MayDangleUntriaged {};

}  // namespace unretained_traits

namespace internal {

template <typename T,
          typename UnretainedTrait,
          RawPtrTraits PtrTraits = RawPtrTraits::kEmpty>
class UnretainedWrapper {
  // Note that if `PtrTraits` already includes `MayDangle`, `DanglingRawPtrType`
  // will be identical to `raw_ptr<T, PtrTraits>`.
  using DanglingRawPtrType = MayBeDangling<T, PtrTraits>;

 public:
  // We want the getter type to match the receiver parameter that it is passed
  // into, to minimize `raw_ptr<T>` <-> `T*` conversions. We also would like to
  // match `StorageType`, but sometimes we can't have both, as shown in
  // https://docs.google.com/document/d/1dLM34aKqbNBfRdOYxxV_T-zQU4J5wjmXwIBJZr7JvZM/edit
  // When we can't have both, prefer the former, mostly because
  // `GetPtrType`=`raw_ptr<T>` would break if e.g. `UnretainedWrapper()` is
  // constructed using `char*`, but the receiver is of type `std::string&`.
  // This is enforced by `static_assert()`s in `ParamCanBeBound`.
  using GetPtrType = std::conditional_t<
      raw_ptr_traits::IsSupportedType<T>::value &&
          std::same_as<UnretainedTrait, unretained_traits::MayDangle>,
      DanglingRawPtrType,
      T*>;

  // Raw pointer makes sense only if there are no `PtrTrait`s. If there are,
  // it means that a `raw_ptr` is being passed, so use the ctors below instead.
  explicit UnretainedWrapper(T* o)
    requires(PtrTraits == RawPtrTraits::kEmpty)
      : ptr_(o) {
    VerifyPreconditions();
  }

  explicit UnretainedWrapper(const raw_ptr<T, PtrTraits>& o)
    requires(raw_ptr_traits::IsSupportedType<T>::value)
      : ptr_(o) {
    VerifyPreconditions();
  }

  explicit UnretainedWrapper(raw_ptr<T, PtrTraits>&& o)
    requires(raw_ptr_traits::IsSupportedType<T>::value)
      : ptr_(std::move(o)) {
    VerifyPreconditions();
  }

  GetPtrType get() const { return GetInternal(ptr_); }

  // True if this type is valid. When this is false, a `static_assert` will have
  // been fired explaining why.
  static constexpr bool value = SupportsUnretained<T>;

 private:
  // `ptr_` is either a `raw_ptr` or a regular C++ pointer.
  template <typename U>
    requires std::same_as<T, U>
  static GetPtrType GetInternal(U* ptr) {
    return ptr;
  }
  template <typename U, RawPtrTraits Traits>
    requires std::same_as<T, U>
  static GetPtrType GetInternal(const raw_ptr<U, Traits>& ptr) {
    if constexpr (std::same_as<UnretainedTrait,
                               unretained_traits::MayNotDangle>) {
      ptr.ReportIfDangling();
    }
    return ptr;
  }

  // `Unretained()` arguments often dangle by design (a common design pattern
  // is to manage an object's lifetime inside the callback itself, using
  // stateful information), so disable direct dangling pointer detection
  // of `ptr_`.
  //
  // If the callback is invoked, dangling pointer detection will be triggered
  // before invoking the bound functor (unless stated otherwise, see
  // `UnsafeDangling()` and `UnsafeDanglingUntriaged()`), when retrieving the
  // pointer value via `get()` above.
  using StorageType =
      std::conditional_t<raw_ptr_traits::IsSupportedType<T>::value,
                         DanglingRawPtrType,
                         T*>;
  // Avoid converting between different `raw_ptr` types when calling `get()`.
  // It is allowable to convert `raw_ptr<T>` -> `T*`, but not in the other
  // direction. See the comment by `GetPtrType` describing for more details.
  static_assert(std::is_pointer_v<GetPtrType> ||
                std::same_as<GetPtrType, StorageType>);

  // Forces `value` to be materialized, performing a compile-time check of the
  // preconditions if it hasn't already occurred. This is called from every
  // constructor so the wrappers in bind.h don't have to each check it, and so
  // no one can go around them and construct this underlying type directly.
  static constexpr void VerifyPreconditions() {
    // Using `static_assert(value);` here would work but fire an extra error.
    std::ignore = value;
  }

  StorageType ptr_;
};

// Storage type for `std::reference_wrapper` so `BindState` can internally store
// unprotected references using `raw_ref`.
//
// `std::reference_wrapper<T>` and `T&` do not work, since the reference
// lifetime is not safely protected by MiraclePtr.
//
// `UnretainedWrapper<T>` and `raw_ptr<T>` do not work, since `BindUnwrapTraits`
// would try to pass by `T*` rather than `T&`.
template <typename T,
          typename UnretainedTrait,
          RawPtrTraits PtrTraits = RawPtrTraits::kEmpty>
class UnretainedRefWrapper {
 public:
  // Raw reference makes sense only if there are no `PtrTrait`s. If there are,
  // it means that a `raw_ref` is being passed, so use the ctors below instead.
  explicit UnretainedRefWrapper(T& o)
    requires(PtrTraits == RawPtrTraits::kEmpty)
      : ref_(o) {
    VerifyPreconditions();
  }

  explicit UnretainedRefWrapper(const raw_ref<T, PtrTraits>& o)
    requires(raw_ptr_traits::IsSupportedType<T>::value)
      : ref_(o) {
    VerifyPreconditions();
  }

  explicit UnretainedRefWrapper(raw_ref<T, PtrTraits>&& o)
    requires(raw_ptr_traits::IsSupportedType<T>::value)
      : ref_(std::move(o)) {
    VerifyPreconditions();
  }

  T& get() const { return GetInternal(ref_); }

  // See comments in `UnretainedWrapper` regarding this and
  // `VerifyPreconditions()`.
  static constexpr bool value = SupportsUnretained<T>;

 private:
  // `ref_` is either a `raw_ref` or a regular C++ reference.
  template <typename U>
    requires std::same_as<T, U>
  static T& GetInternal(U& ref) {
    return ref;
  }
  template <typename U, RawPtrTraits Traits>
    requires std::same_as<T, U>
  static T& GetInternal(const raw_ref<U, Traits>& ref) {
    // The ultimate goal is to crash when a callback is invoked with a
    // dangling pointer. This is checked here. For now, it is configured to
    // either crash, DumpWithoutCrashing or be ignored. This depends on the
    // `PartitionAllocUnretainedDanglingPtr` feature.
    if constexpr (std::is_same_v<UnretainedTrait,
                                 unretained_traits::MayNotDangle>) {
      ref.ReportIfDangling();
    }
    // We can't use `operator*` here, we need to use `raw_ptr`'s
    // `GetForExtraction` instead of `GetForDereference`. If we did use
    // `GetForDereference` then we'd crash in ASAN builds on calling a bound
    // callback with a dangling reference parameter even if that parameter is
    // not used. This could hide a later unprotected issue that would be reached
    // in release builds.
    return ref.get();
  }

  // `Unretained()` arguments often dangle by design (a common design pattern
  // is to manage an object's lifetime inside the callback itself, using
  // stateful information), so disable direct dangling pointer detection
  // of `ref_`.
  //
  // If the callback is invoked, dangling pointer detection will be triggered
  // before invoking the bound functor (unless stated otherwise, see
  // `UnsafeDangling()` and `UnsafeDanglingUntriaged()`), when retrieving the
  // pointer value via `get()` above.
  using StorageType =
      std::conditional_t<raw_ptr_traits::IsSupportedType<T>::value,
                         raw_ref<T, DisableDanglingPtrDetection>,
                         T&>;

  static constexpr void VerifyPreconditions() { std::ignore = value; }

  StorageType ref_;
};

// Can't use `is_instantiation` to detect the unretained wrappers, since they
// have non-type template params.
template <template <typename, typename, RawPtrTraits> typename WrapperT,
          typename T>
inline constexpr bool kIsUnretainedWrapper = false;

template <template <typename, typename, RawPtrTraits> typename WrapperT,
          typename T,
          typename UnretainedTrait,
          RawPtrTraits PtrTraits>
inline constexpr bool
    kIsUnretainedWrapper<WrapperT, WrapperT<T, UnretainedTrait, PtrTraits>> =
        true;

// The class is used to wrap `UnretainedRefWrapper` when the latter is used as
// a method receiver (a reference on `this` argument). This is needed because
// the internal callback mechanism expects the receiver to have the type
// `MyClass*` and to have `operator*`.
// This is used as storage.
template <typename T, typename UnretainedTrait, RawPtrTraits PtrTraits>
class UnretainedRefWrapperReceiver {
 public:
  // NOLINTNEXTLINE(google-explicit-constructor)
  UnretainedRefWrapperReceiver(
      UnretainedRefWrapper<T, UnretainedTrait, PtrTraits>&& obj)
      : obj_(std::move(obj)) {}

  T& operator*() const { return obj_.get(); }
  T* operator->() const { return &obj_.get(); }

 private:
  UnretainedRefWrapper<T, UnretainedTrait, PtrTraits> obj_;
};

// `MethodReceiverStorage` converts the current receiver type to its stored
// type. For instance, it converts pointers to `scoped_refptr`, and wraps
// `UnretainedRefWrapper` to make it compliant with the internal callback
// invocation mechanism.
template <typename T>
struct MethodReceiverStorage {
  using Type =
      std::conditional_t<IsPointerV<T>, scoped_refptr<RemovePointerT<T>>, T>;
};

template <typename T, typename UnretainedTrait, RawPtrTraits PtrTraits>
struct MethodReceiverStorage<
    UnretainedRefWrapper<T, UnretainedTrait, PtrTraits>> {
  // We can't use `UnretainedRefWrapper` as a receiver directly (see
  // `UnretainedRefWrapperReceiver` for why).
  using Type = UnretainedRefWrapperReceiver<T, UnretainedTrait, PtrTraits>;
};

template <typename T>
class RetainedRefWrapper {
 public:
  explicit RetainedRefWrapper(T* o) : ptr_(o) {}
  explicit RetainedRefWrapper(scoped_refptr<T> o) : ptr_(std::move(o)) {}
  T* get() const { return ptr_.get(); }

 private:
  scoped_refptr<T> ptr_;
};

template <typename T>
struct IgnoreResultHelper {
  explicit IgnoreResultHelper(T functor) : functor_(std::move(functor)) {}
  explicit operator bool() const { return !!functor_; }

  T functor_;
};

template <typename T, typename Deleter = std::default_delete<T>>
class OwnedWrapper {
 public:
  explicit OwnedWrapper(T* o) : ptr_(o) {}
  explicit OwnedWrapper(std::unique_ptr<T, Deleter>&& ptr)
      : ptr_(std::move(ptr)) {}
  T* get() const { return ptr_.get(); }

 private:
  std::unique_ptr<T, Deleter> ptr_;
};

template <typename T>
class OwnedRefWrapper {
 public:
  explicit OwnedRefWrapper(const T& t) : t_(t) {}
  explicit OwnedRefWrapper(T&& t) : t_(std::move(t)) {}
  T& get() const { return t_; }

 private:
  mutable T t_;
};

// `PassedWrapper` is a copyable adapter for a scoper that ignores `const`.
//
// It is needed to get around the fact that `Bind()` takes a const reference to
// all its arguments.  Because `Bind()` takes a const reference to avoid
// unnecessary copies, it is incompatible with movable-but-not-copyable
// types; doing a destructive "move" of the type into `Bind()` would violate
// the const correctness.
//
// This conundrum cannot be solved without either rvalue references or an O(2^n)
// blowup of `Bind()` templates to handle each combination of regular types and
// movable-but-not-copyable types.  Thus we introduce a wrapper type that is
// copyable to transmit the correct type information down into `BindState<>`.
// Ignoring `const` in this type makes sense because it is only created when we
// are explicitly trying to do a destructive move.
//
// Two notes:
//  1) `PassedWrapper` supports any type that has a move constructor, however
//     the type will need to be specifically allowed in order for it to be
//     bound to a `Callback`. We guard this explicitly at the call of `Passed()`
//     to make for clear errors. Things not given to `Passed()` will be
//     forwarded and stored by value which will not work for general move-only
//     types.
//  2) `is_valid_` is distinct from `nullptr` because it is valid to bind a null
//     scoper to a `Callback` and allow the `Callback` to execute once.
//
// TODO(crbug.com/1326449): We have rvalue references and such now. Remove.
template <typename T>
class PassedWrapper {
 public:
  explicit PassedWrapper(T&& scoper) : scoper_(std::move(scoper)) {}
  PassedWrapper(PassedWrapper&& other)
      : is_valid_(other.is_valid_), scoper_(std::move(other.scoper_)) {}
  T Take() const {
    CHECK(is_valid_);
    is_valid_ = false;
    return std::move(scoper_);
  }

 private:
  mutable bool is_valid_ = true;
  mutable T scoper_;
};

template <typename T>
using Unwrapper = BindUnwrapTraits<std::decay_t<T>>;

template <typename T>
decltype(auto) Unwrap(T&& o) {
  return Unwrapper<T>::Unwrap(std::forward<T>(o));
}

// `kIsWeakMethod` is a helper that determines if we are binding a `WeakPtr<>`
// to a method. It is used internally by `Bind()` to select the correct
// `InvokeHelper` that will no-op itself in the event the `WeakPtr<>` for the
// target object is invalidated.
//
// The first argument should be the type of the object that will be received by
// the method.
template <bool is_method, typename... Args>
inline constexpr bool kIsWeakMethod = false;

template <typename T, typename... Args>
inline constexpr bool kIsWeakMethod<true, T, Args...> =
    IsWeakReceiver<T>::value;

// Packs a list of types to hold them in a single type.
template <typename... Types>
struct TypeList {};

// Implements `DropTypeListItem`.
template <size_t n, typename List>
  requires is_instantiation<TypeList, List>
struct DropTypeListItemImpl {
  using Type = List;
};

template <size_t n, typename T, typename... List>
  requires(n > 0)
struct DropTypeListItemImpl<n, TypeList<T, List...>>
    : DropTypeListItemImpl<n - 1, TypeList<List...>> {};

// A type-level function that drops `n` list items from a given `TypeList`.
template <size_t n, typename List>
using DropTypeListItem = typename DropTypeListItemImpl<n, List>::Type;

// Implements `TakeTypeListItem`.
template <size_t n, typename List, typename... Accum>
  requires is_instantiation<TypeList, List>
struct TakeTypeListItemImpl {
  using Type = TypeList<Accum...>;
};

template <size_t n, typename T, typename... List, typename... Accum>
  requires(n > 0)
struct TakeTypeListItemImpl<n, TypeList<T, List...>, Accum...>
    : TakeTypeListItemImpl<n - 1, TypeList<List...>, Accum..., T> {};

// A type-level function that takes the first `n` items from a given `TypeList`;
// e.g. `TakeTypeListItem<3, TypeList<A, B, C, D>>` -> `TypeList<A, B, C>`.
template <size_t n, typename List>
using TakeTypeListItem = typename TakeTypeListItemImpl<n, List>::Type;

// Implements `MakeFunctionType`.
template <typename R, typename ArgList>
struct MakeFunctionTypeImpl;

template <typename R, typename... Args>
struct MakeFunctionTypeImpl<R, TypeList<Args...>> {
  using Type = R(Args...);
};

// A type-level function that constructs a function type that has `R` as its
// return type and has a `TypeList`'s items as its arguments.
template <typename R, typename ArgList>
using MakeFunctionType = typename MakeFunctionTypeImpl<R, ArgList>::Type;

// Implements `ExtractArgs` and `ExtractReturnType`.
template <typename Signature>
struct ExtractArgsImpl;

template <typename R, typename... Args>
struct ExtractArgsImpl<R(Args...)> {
  using ReturnType = R;
  using ArgsList = TypeList<Args...>;
};

// A type-level function that extracts function arguments into a `TypeList`;
// e.g. `ExtractArgs<R(A, B, C)>` -> `TypeList<A, B, C>`.
template <typename Signature>
using ExtractArgs = typename ExtractArgsImpl<Signature>::ArgsList;

// A type-level function that extracts the return type of a function.
// e.g. `ExtractReturnType<R(A, B, C)>` -> `R`.
template <typename Signature>
using ExtractReturnType = typename ExtractArgsImpl<Signature>::ReturnType;

template <typename Callable,
          typename Signature = decltype(&Callable::operator())>
struct ExtractCallableRunTypeImpl;

template <typename Callable, typename R, typename... Args>
struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...)> {
  using Type = R(Args...);
};

template <typename Callable, typename R, typename... Args>
struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...) const> {
  using Type = R(Args...);
};

template <typename Callable, typename R, typename... Args>
struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...) noexcept> {
  using Type = R(Args...);
};

template <typename Callable, typename R, typename... Args>
struct ExtractCallableRunTypeImpl<Callable,
                                  R (Callable::*)(Args...) const noexcept> {
  using Type = R(Args...);
};

// Evaluated to the RunType of the given callable type; e.g.
// `ExtractCallableRunType<decltype([](int, char*) { return 0.1; })>` ->
//     `double(int, char*)`.
template <typename Callable>
using ExtractCallableRunType =
    typename ExtractCallableRunTypeImpl<Callable>::Type;

// `IsCallableObject` is true iff `Functor` has a non-overloaded `operator()`.
// This means it fails on some real callable objects, e.g. with templated or
// overloaded `operator()`s. E.g.:
//   static_assert(!IsCallableObject<void(*)()>);
//
//   struct Foo {};
//   static_assert(!IsCallableObject<void(Foo::*)()>);
//
//   int i = 0;
//   auto f = [i] {};
//   static_assert(!IsCallableObject<decltype(f)>);
//
//   // TODO(crbug.com/1409914): Support.
//   struct S {
//     int operator()(int);
//     char operator()(char);
//   };
//   static_assert(!IsCallableObject<S>);
// ```
template <typename Functor>
concept IsCallableObject = requires { &Functor::operator(); };

// `HasRefCountedTypeAsRawPtr` is true when any of the `Args` is a raw pointer
// to a `RefCounted` type.
template <typename... Ts>
concept HasRefCountedTypeAsRawPtr =
    std::disjunction_v<NeedsScopedRefptrButGetsRawPtr<Ts>...>;

// `ForceVoidReturn<>` converts a signature to have a `void` return type.
template <typename Sig>
struct ForceVoidReturn;

template <typename R, typename... Args>
struct ForceVoidReturn<R(Args...)> {
  using RunType = void(Args...);
};

// `FunctorTraits<>`
//
// See description at top of file.
template <typename Functor>
struct FunctorTraits;

// Callable types.
// This specialization handles lambdas (captureless and capturing) and functors
// with a call operator. Capturing lambdas and stateful functors are explicitly
// disallowed by `BindHelper<>::Bind()`; e.g.:
// ```
//   // Captureless lambda: Allowed
//   [] { return 42; };
//
//   // Capturing lambda: Disallowed
//   int x;
//   [x] { return x; };
//
//   // Empty class with `operator()()`: Allowed
//   struct Foo {
//     void operator()() const {}
//     // No non-`static` member variables and no virtual functions.
//   };
// ```
template <typename Functor>
  requires IsCallableObject<Functor>
struct FunctorTraits<Functor> {
  using RunType = ExtractCallableRunType<Functor>;
  static constexpr bool is_method = false;
  static constexpr bool is_nullable = false;
  static constexpr bool is_callback = false;
  static constexpr bool is_stateless = std::is_empty_v<Functor>;

  template <typename RunFunctor, typename... RunArgs>
  static ExtractReturnType<RunType> Invoke(RunFunctor&& functor,
                                           RunArgs&&... args) {
    return std::forward<RunFunctor>(functor)(std::forward<RunArgs>(args)...);
  }
};

// Functions.
template <typename R, typename... Args>
struct FunctorTraits<R (*)(Args...)> {
  using RunType = R(Args...);
  static constexpr bool is_method = false;
  static constexpr bool is_nullable = true;
  static constexpr bool is_callback = false;
  static constexpr bool is_stateless = true;

  template <typename Function, typename... RunArgs>
  static R Invoke(Function&& function, RunArgs&&... args) {
    return std::forward<Function>(function)(std::forward<RunArgs>(args)...);
  }
};

template <typename R, typename... Args>
struct FunctorTraits<R (*)(Args...) noexcept> : FunctorTraits<R (*)(Args...)> {
};

#if BUILDFLAG(IS_WIN) && !defined(ARCH_CPU_64_BITS)

// `__stdcall` functions.
template <typename R, typename... Args>
struct FunctorTraits<R(__stdcall*)(Args...)> : FunctorTraits<R (*)(Args...)> {};

template <typename R, typename... Args>
struct FunctorTraits<R(__stdcall*)(Args...) noexcept>
    : FunctorTraits<R (*)(Args...)> {};

// `__fastcall` functions.
template <typename R, typename... Args>
struct FunctorTraits<R(__fastcall*)(Args...)> : FunctorTraits<R (*)(Args...)> {
};

template <typename R, typename... Args>
struct FunctorTraits<R(__fastcall*)(Args...) noexcept>
    : FunctorTraits<R (*)(Args...)> {};

#endif  // BUILDFLAG(IS_WIN) && !defined(ARCH_CPU_64_BITS)

#if __OBJC__ && HAS_FEATURE(objc_arc)

// Objective-C blocks. Blocks can be bound as the compiler will ensure their
// lifetimes will be correctly managed.
template <typename R, typename... Args>
struct FunctorTraits<R (^)(Args...)> {
  using RunType = R(Args...);
  static constexpr bool is_method = false;
  static constexpr bool is_nullable = true;
  static constexpr bool is_callback = false;
  static constexpr bool is_stateless = true;

  template <typename BlockType, typename... RunArgs>
  static R Invoke(BlockType&& block, RunArgs&&... args) {
    // According to LLVM documentation (§ 6.3), "local variables of automatic
    // storage duration do not have precise lifetime." Use
    // `objc_precise_lifetime` to ensure that the Objective-C block is not
    // deallocated until it has finished executing even if the `Callback<>` is
    // destroyed during the block execution.
    // https://clang.llvm.org/docs/AutomaticReferenceCounting.html#precise-lifetime-semantics
    __attribute__((objc_precise_lifetime)) R (^scoped_block)(Args...) = block;
    return scoped_block(std::forward<RunArgs>(args)...);
  }
};

#endif  // __OBJC__ && HAS_FEATURE(objc_arc)

// Methods.
template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (Receiver::*)(Args...)> {
  using RunType = R(Receiver*, Args...);
  static constexpr bool is_method = true;
  static constexpr bool is_nullable = true;
  static constexpr bool is_callback = false;
  static constexpr bool is_stateless = true;

  template <typename Method, typename ReceiverPtr, typename... RunArgs>
  static R Invoke(Method method,
                  ReceiverPtr&& receiver_ptr,
                  RunArgs&&... args) {
    return ((*receiver_ptr).*method)(std::forward<RunArgs>(args)...);
  }
};

template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (Receiver::*)(Args...) noexcept>
    : FunctorTraits<R (Receiver::*)(Args...)> {};

template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (Receiver::*)(Args...) const>
    : FunctorTraits<R (Receiver::*)(Args...)> {
  using RunType = R(const Receiver*, Args...);
};

template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (Receiver::*)(Args...) const noexcept>
    : FunctorTraits<R (Receiver::*)(Args...) const> {};

#if BUILDFLAG(IS_WIN) && !defined(ARCH_CPU_64_BITS)

// `__stdcall` methods.
template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (__stdcall Receiver::*)(Args...)>
    : public FunctorTraits<R (Receiver::*)(Args...)> {};

template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (__stdcall Receiver::*)(Args...) noexcept>
    : public FunctorTraits<R (Receiver::*)(Args...)> {};

template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (__stdcall Receiver::*)(Args...) const>
    : public FunctorTraits<R (Receiver::*)(Args...) const> {};

template <typename R, typename Receiver, typename... Args>
struct FunctorTraits<R (__stdcall Receiver::*)(Args...) const noexcept>
    : public FunctorTraits<R (Receiver::*)(Args...) const> {};

#endif  // BUILDFLAG(IS_WIN) && !defined(ARCH_CPU_64_BITS)

// `IgnoreResult`s.
template <typename T>
struct FunctorTraits<IgnoreResultHelper<T>> : FunctorTraits<T> {
  using RunType =
      typename ForceVoidReturn<typename FunctorTraits<T>::RunType>::RunType;

  template <typename IgnoreResultType, typename... RunArgs>
  static void Invoke(IgnoreResultType&& ignore_result_helper,
                     RunArgs&&... args) {
    FunctorTraits<T>::Invoke(
        std::forward<IgnoreResultType>(ignore_result_helper).functor_,
        std::forward<RunArgs>(args)...);
  }
};

// `OnceCallback`s.
template <typename R, typename... Args>
struct FunctorTraits<OnceCallback<R(Args...)>> {
  using RunType = R(Args...);
  static constexpr bool is_method = false;
  static constexpr bool is_nullable = true;
  static constexpr bool is_callback = true;
  static constexpr bool is_stateless = true;

  template <typename CallbackType, typename... RunArgs>
  static R Invoke(CallbackType&& callback, RunArgs&&... args) {
    DCHECK(!callback.is_null());
    return std::forward<CallbackType>(callback).Run(
        std::forward<RunArgs>(args)...);
  }
};

// `RepeatingCallback`s.
template <typename R, typename... Args>
struct FunctorTraits<RepeatingCallback<R(Args...)>> {
  using RunType = R(Args...);
  static constexpr bool is_method = false;
  static constexpr bool is_nullable = true;
  static constexpr bool is_callback = true;
  static constexpr bool is_stateless = true;

  template <typename CallbackType, typename... RunArgs>
  static R Invoke(CallbackType&& callback, RunArgs&&... args) {
    DCHECK(!callback.is_null());
    return std::forward<CallbackType>(callback).Run(
        std::forward<RunArgs>(args)...);
  }
};

template <typename Functor>
using MakeFunctorTraits = FunctorTraits<std::decay_t<Functor>>;

// `StorageTraits<>`
//
// See description at top of file.
template <typename T>
struct StorageTraits {
  // The type to use for storing the bound arg inside `BindState`.
  using Type = T;

  // True iff all compile-time preconditions for using this specialization are
  // satisfied. Specializations that set this to `false` should ensure a
  // `static_assert()` explains why.
  static constexpr bool value = true;
};

// For `T*`, store as `UnretainedWrapper<T>` for safety, as it internally uses
// `raw_ptr<T>` (when possible).
template <typename T>
struct StorageTraits<T*> {
  using Type = UnretainedWrapper<T, unretained_traits::MayNotDangle>;
  static constexpr bool value = Type::value;
};

// For `raw_ptr<T>`, store as `UnretainedWrapper<T>` for safety. This may seem
// contradictory, but this ensures guaranteed protection for the pointer even
// during execution of callbacks with parameters of type `raw_ptr<T>`.
template <typename T, RawPtrTraits PtrTraits>
struct StorageTraits<raw_ptr<T, PtrTraits>> {
  using Type = UnretainedWrapper<T, unretained_traits::MayNotDangle, PtrTraits>;
  static constexpr bool value = Type::value;
};

// Unwrap `std::reference_wrapper` and store it in a custom wrapper so that
// references are also protected with `raw_ptr<T>`.
template <typename T>
struct StorageTraits<std::reference_wrapper<T>> {
  using Type = UnretainedRefWrapper<T, unretained_traits::MayNotDangle>;
  static constexpr bool value = Type::value;
};

template <typename T>
using ValidateStorageTraits = StorageTraits<std::decay_t<T>>;

// `InvokeHelper<>`
//
// There are 2 logical `InvokeHelper<>` specializations: normal, weak.
//
// The normal type just calls the underlying runnable.
//
// Weak calls need special syntax that is applied to the first argument to check
// if they should no-op themselves.
template <bool is_weak_call, typename ReturnType, size_t... indices>
struct InvokeHelper;

template <typename ReturnType, size_t... indices>
struct InvokeHelper<false, ReturnType, indices...> {
  template <typename Functor, typename BoundArgsTuple, typename... RunArgs>
  static inline ReturnType MakeItSo(Functor&& functor,
                                    BoundArgsTuple&& bound,
                                    RunArgs&&... args) {
    return MakeFunctorTraits<Functor>::Invoke(
        std::forward<Functor>(functor),
        Unwrap(std::get<indices>(std::forward<BoundArgsTuple>(bound)))...,
        std::forward<RunArgs>(args)...);
  }
};

template <typename ReturnType, size_t index_target, size_t... index_tail>
struct InvokeHelper<true, ReturnType, index_target, index_tail...> {
  template <typename Functor, typename BoundArgsTuple, typename... RunArgs>
  static inline void MakeItSo(Functor&& functor,
                              BoundArgsTuple&& bound,
                              RunArgs&&... args) {
    static_assert(index_target == 0);
    // Note the validity of the weak pointer should be tested _after_ it is
    // unwrapped, otherwise it creates a race for weak pointer implementations
    // that allow cross-thread usage and perform `Lock()` in `Unwrap()` traits.
    const auto& target = Unwrap(std::get<0>(bound));
    if (!target) {
      return;
    }
    MakeFunctorTraits<Functor>::Invoke(
        std::forward<Functor>(functor), target,
        Unwrap(std::get<index_tail>(std::forward<BoundArgsTuple>(bound)))...,
        std::forward<RunArgs>(args)...);
  }
};

// `Invoker<>`
//
// See description at the top of the file.
template <typename StorageType, typename UnboundRunType>
struct Invoker;

template <typename StorageType, typename R, typename... UnboundArgs>
struct Invoker<StorageType, R(UnboundArgs...)> {
 private:
  using Indices = std::make_index_sequence<
      std::tuple_size_v<decltype(StorageType::bound_args_)>>;

 public:
  static R RunOnce(BindStateBase* base,
                   PassingType<UnboundArgs>... unbound_args) {
    auto* const storage = static_cast<StorageType*>(base);
    return RunImpl(std::move(storage->functor_),
                   std::move(storage->bound_args_), Indices(),
                   std::forward<UnboundArgs>(unbound_args)...);
  }

  static R Run(BindStateBase* base, PassingType<UnboundArgs>... unbound_args) {
    auto* const storage = static_cast<const StorageType*>(base);
    return RunImpl(storage->functor_, storage->bound_args_, Indices(),
                   std::forward<UnboundArgs>(unbound_args)...);
  }

 private:
  // The "templated struct with a lambda that asserts" pattern below is used
  // repeatedly in Bind/Callback code to verify compile-time preconditions. The
  // goal is to print only the root cause failure when users violate a
  // precondition, and not also a host of resulting compile errors.
  //
  // There are three key aspects:
  //   1. By placing the assertion inside a lambda that initializes a variable,
  //      the assertion will not be verified until the compiler tries to read
  //      the value of that variable. This allows the containing types to be
  //      complete. As a result, code that needs to know if the assertion failed
  //      can read the variable's value and get the right answer. (If we instead
  //      placed the assertion at struct scope, the resulting type would be
  //      incomplete when the assertion failed; in practice, reading a
  //      `constexpr` member of an incomplete type seems to return the default
  //      value regardless of what the code tried to set the value to, which
  //      makes it impossible for other code to check whether the assertion
  //      failed.)
  //   2. Code that will not successfully compile unless the assertion holds is
  //      guarded by a constexpr if that checks the variable.
  //   3. By placing the variable inside an independent, templated struct and
  //      naming it `value`, we allow checking multiple conditions via
  //      `std::conjunction_v<>`. This short-circuits type instantiation, so
  //      that when one condition fails, the others are never examined and thus
  //      never assert. As a result, we can verify dependent conditions without
  //      worrying that "if one fails, we'll get errors from several others".
  //      (This would not be true if we simply checked all the values with `&&`,
  //      which would instantiate all the types before evaluating the
  //      expression.)
  //
  // For caller convenience and to avoid potential repetition, the actual
  // condition to be checked is always used as the default value of a template
  // argument, so callers can simply instantiate the struct with no template
  // params to verify the condition.

  // Weak calls are only supported for functions with a `void` return type.
  // Otherwise, the desired function result would be unclear if the `WeakPtr<>`
  // is invalidated. In theory, we could support default-constructible return
  // types (and return the default value) or allow callers to specify a default
  // return value via a template arg. It's not clear these are necessary.
  template <bool is_weak_call, bool v = !is_weak_call || std::is_void_v<R>>
  struct WeakCallReturnsVoid {
    static constexpr bool value = [] {
      static_assert(v,
                    "WeakPtrs can only bind to methods without return values.");
      return v;
    }();
  };

  template <typename Functor, typename BoundArgsTuple, size_t... indices>
  static inline R RunImpl(Functor&& functor,
                          BoundArgsTuple&& bound,
                          std::index_sequence<indices...>,
                          UnboundArgs&&... unbound_args) {
#if BUILDFLAG(USE_ASAN_BACKUP_REF_PTR)
    RawPtrAsanBoundArgTracker raw_ptr_asan_bound_arg_tracker;
    raw_ptr_asan_bound_arg_tracker.AddArgs(
        std::get<indices>(std::forward<BoundArgsTuple>(bound))...,
        std::forward<UnboundArgs>(unbound_args)...);
#endif  // BUILDFLAG(USE_ASAN_BACKUP_REF_PTR)

    using DecayedArgsTuple = std::decay_t<BoundArgsTuple>;
    static constexpr bool kIsWeakCall =
        kIsWeakMethod<MakeFunctorTraits<Functor>::is_method,
                      std::tuple_element_t<indices, DecayedArgsTuple>...>;
    if constexpr (WeakCallReturnsVoid<kIsWeakCall>::value) {
      // Do not `Unwrap()` here, as that immediately triggers dangling pointer
      // detection. Dangling pointer detection should only be triggered if the
      // callback is not cancelled, but cancellation status is not determined
      // until later inside the `InvokeHelper::MakeItSo()` specialization for
      // weak calls.
      //
      // Dangling pointers when invoking a cancelled callback are not considered
      // a memory safety error because protecting raw pointers usage with weak
      // receivers (where the weak receiver usually own the pointed objects) is
      // a common and broadly used pattern in the codebase.
      return InvokeHelper<kIsWeakCall, R, indices...>::MakeItSo(
          std::forward<Functor>(functor), std::forward<BoundArgsTuple>(bound),
          std::forward<UnboundArgs>(unbound_args)...);
    }
  }
};

// Allow binding a method call with no receiver.
// TODO(crbug.com/1511757): Remove or make safe.
template <typename... Unused>
void VerifyMethodReceiver(Unused&&...) {}

template <typename Receiver, typename... Unused>
void VerifyMethodReceiver(Receiver&& receiver, Unused&&...) {
  // Asserts that a callback is not the first owner of a ref-counted receiver.
  if constexpr (IsPointerV<std::decay_t<Receiver>> &&
                IsRefCountedType<RemovePointerT<std::decay_t<Receiver>>>) {
    DCHECK(receiver);

    // It's error prone to make the implicit first reference to ref-counted
    // types. In the example below, `BindOnce()` would make the implicit first
    // reference to the ref-counted `Foo`. If `PostTask()` failed or the posted
    // task ran fast enough, the newly created instance could be destroyed
    // before `oo` makes another reference.
    // ```
    //   Foo::Foo() {
    //     ThreadPool::PostTask(FROM_HERE, BindOnce(&Foo::Bar, this));
    //   }
    //
    //   scoped_refptr<Foo> oo = new Foo();
    // ```
    //
    // Hence, `Bind()` refuses to create the first reference to ref-counted
    // objects, and `DCHECK()`s otherwise. As above, that typically happens
    // around `PostTask()` in their constructors, and such objects can be
    // destroyed before `new` returns if the tasks resolve fast enough.
    //
    // Instead, consider adding a static factory, and keeping the first
    // reference alive explicitly.
    // ```
    //   // static
    //   scoped_refptr<Foo> Foo::Create() {
    //     auto foo = base::WrapRefCounted(new Foo());
    //     ThreadPool::PostTask(FROM_HERE, BindOnce(&Foo::Bar, foo));
    //     return foo;
    //   }
    //
    //   scoped_refptr<Foo> oo = Foo::Create();
    // ```
    DCHECK(receiver->HasAtLeastOneRef());
  }
}

// `BindState<>`
//
// This stores all the state passed into `Bind()`.
template <typename Functor, typename... BoundArgs>
struct BindState final : BindStateBase {
 private:
  using FunctorTraits = MakeFunctorTraits<Functor>;
  using BoundArgsTuple = std::tuple<BoundArgs...>;

 public:
  template <typename ForwardFunctor, typename... ForwardBoundArgs>
  static BindState* Create(BindStateBase::InvokeFuncStorage invoke_func,
                           ForwardFunctor&& functor,
                           ForwardBoundArgs&&... bound_args) {
    if constexpr (FunctorTraits::is_method) {
      VerifyMethodReceiver(bound_args...);
    }
    return new BindState(invoke_func, std::forward<ForwardFunctor>(functor),
                         std::forward<ForwardBoundArgs>(bound_args)...);
  }

  Functor functor_;
  BoundArgsTuple bound_args_;

 private:
  using CancellationTraits =
      CallbackCancellationTraits<Functor, BoundArgsTuple>;

  template <typename ForwardFunctor, typename... ForwardBoundArgs>
    requires CancellationTraits::is_cancellable
  explicit BindState(BindStateBase::InvokeFuncStorage invoke_func,
                     ForwardFunctor&& functor,
                     ForwardBoundArgs&&... bound_args)
      : BindStateBase(invoke_func, &Destroy, &QueryCancellationTraits),
        functor_(std::forward<ForwardFunctor>(functor)),
        bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
    CheckFunctorIsNonNull();
  }

  template <typename ForwardFunctor, typename... ForwardBoundArgs>
    requires(!CancellationTraits::is_cancellable)
  explicit BindState(BindStateBase::InvokeFuncStorage invoke_func,
                     ForwardFunctor&& functor,
                     ForwardBoundArgs&&... bound_args)
      : BindStateBase(invoke_func, &Destroy),
        functor_(std::forward<ForwardFunctor>(functor)),
        bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
    CheckFunctorIsNonNull();
  }

  ~BindState() = default;

  static bool QueryCancellationTraits(
      const BindStateBase* base,
      BindStateBase::CancellationQueryMode mode) {
    auto* const storage = static_cast<const BindState*>(base);
    static constexpr std::make_index_sequence<sizeof...(BoundArgs)> kIndices;
    return (mode == BindStateBase::CancellationQueryMode::kIsCancelled)
               ? storage->IsCancelled(kIndices)
               : storage->MaybeValid(kIndices);
  }

  static void Destroy(const BindStateBase* self) {
    delete static_cast<const BindState*>(self);
  }

  // Helpers to do arg tuple expansion.
  template <size_t... indices>
  bool IsCancelled(std::index_sequence<indices...>) const {
    return CancellationTraits::IsCancelled(functor_,
                                           std::get<indices>(bound_args_)...);
  }

  template <size_t... indices>
  bool MaybeValid(std::index_sequence<indices...>) const {
    return CancellationTraits::MaybeValid(functor_,
                                          std::get<indices>(bound_args_)...);
  }

  void CheckFunctorIsNonNull() const {
    if constexpr (FunctorTraits::is_nullable) {
      // Check the validity of `functor_` to avoid hard-to-diagnose crashes.
      // Ideally we'd do this unconditionally, but release builds limit this to
      // the case of nested callbacks (e.g. `Bind(callback, ...)`) to limit
      // binary size impact.
      if constexpr (FunctorTraits::is_callback) {
        CHECK(!!functor_);
      } else {
        DCHECK(!!functor_);
      }
    }
  }
};

// Used to determine and validate the appropriate `BindState`. The
// specializations below cover all cases. The members are similar in intent to
// those in `StorageTraits`; see comments there.
template <bool is_method, typename Functor, typename... BoundArgs>
struct ValidateBindStateType;

template <typename Functor, typename... BoundArgs>
struct ValidateBindStateType<false, Functor, BoundArgs...> {
 private:
  template <bool v = !HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>>
  struct NoRawPtrsToRefCountedTypes {
    static constexpr bool value = [] {
      static_assert(
          v, "A parameter is a refcounted type and needs scoped_refptr.");
      return v;
    }();
  };

 public:
  using Type = BindState<std::decay_t<Functor>,
                         typename ValidateStorageTraits<BoundArgs>::Type...>;
  static constexpr bool value =
      std::conjunction_v<NoRawPtrsToRefCountedTypes<>,
                         ValidateStorageTraits<BoundArgs>...>;
};

template <typename Functor>
struct ValidateBindStateType<true, Functor> {
  using Type = BindState<std::decay_t<Functor>>;
  static constexpr bool value = true;
};

template <typename Functor, typename Receiver, typename... BoundArgs>
struct ValidateBindStateType<true, Functor, Receiver, BoundArgs...> {
 private:
  using DecayedReceiver = std::decay_t<Receiver>;
  using ReceiverStorageType =
      typename MethodReceiverStorage<DecayedReceiver>::Type;

  template <bool v = !std::is_array_v<std::remove_reference_t<Receiver>>>
  struct FirstBoundArgIsNotArray {
    static constexpr bool value = [] {
      static_assert(v, "First bound argument to a method cannot be an array.");
      return v;
    }();
  };

  template <bool v = !IsRawRefV<DecayedReceiver>>
  struct ReceiverIsNotRawRef {
    static constexpr bool value = [] {
      static_assert(v, "Receivers may not be raw_ref<T>. If using a raw_ref<T> "
                       "here is safe and has no lifetime concerns, use "
                       "base::Unretained() and document why it's safe.");
      return v;
    }();
  };

  template <bool v = !IsPointerV<DecayedReceiver> ||
                     IsRefCountedType<RemovePointerT<DecayedReceiver>>>
  struct ReceiverIsNotRawPtr {
    static constexpr bool value = [] {
      static_assert(v,
                    "Receivers may not be raw pointers. If using a raw pointer "
                    "here is safe and has no lifetime concerns, use "
                    "base::Unretained() and document why it's safe.");
      return v;
    }();
  };

  template <bool v = !HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>>
  struct NoRawPtrsToRefCountedTypes {
    static constexpr bool value = [] {
      static_assert(
          v, "A parameter is a refcounted type and needs scoped_refptr.");
      return v;
    }();
  };

 public:
  using Type = BindState<std::decay_t<Functor>,
                         ReceiverStorageType,
                         typename ValidateStorageTraits<BoundArgs>::Type...>;
  static constexpr bool value =
      std::conjunction_v<FirstBoundArgIsNotArray<>,
                         ReceiverIsNotRawRef<>,
                         ReceiverIsNotRawPtr<>,
                         NoRawPtrsToRefCountedTypes<>,
                         ValidateStorageTraits<BoundArgs>...>;
};

// Transforms `T` into an unwrapped type, which is passed to the target
// function; e.g.:
// * `is_once` cases:
// ** `TransformToUnwrappedType<true, int&&>` -> `int&&`
// ** `TransformToUnwrappedType<true, const int&>` -> `int&&`
// ** `TransformToUnwrappedType<true, OwnedWrapper<int>&>` -> `int*&&`
// * `!is_once` cases:
// ** `TransformToUnwrappedType<false, int&&>` -> `const int&`
// ** `TransformToUnwrappedType<false, const int&>` -> `const int&`
// ** `TransformToUnwrappedType<false, OwnedWrapper<int>&>` -> `int* const &`
template <bool is_once,
          typename T,
          typename StoredType = std::decay_t<T>,
          typename ForwardedType =
              std::conditional_t<is_once, StoredType&&, const StoredType&>>
using TransformToUnwrappedType =
    decltype(Unwrap(std::declval<ForwardedType>()));

// Used to convert `this` arguments to underlying pointer types; e.g.:
//   `int*` -> `int*`
//   `std::unique_ptr<int>` -> `int*`
//   `int` -> (assertion failure; `this` must be a pointer-like object)
template <typename T>
struct ValidateReceiverType {
 private:
  // Pointer-like receivers use a different specialization, so this never
  // succeeds.
  template <bool v = AlwaysFalse<T>>
  struct ReceiverMustBePointerLike {
    static constexpr bool value = [] {
      static_assert(v,
                    "Cannot convert `this` argument to address. Method calls "
                    "must be bound using a pointer-like `this` argument.");
      return v;
    }();
  };

 public:
  // These members are similar in intent to those in `StorageTraits`; see
  // comments there.
  using Type = T;
  static constexpr bool value = ReceiverMustBePointerLike<>::value;
};

template <typename T>
  requires requires(T&& t) { base::to_address(t); }
struct ValidateReceiverType<T> {
  using Type = decltype(base::to_address(std::declval<T>()));
  static constexpr bool value = true;
};

// Transforms `Args` into unwrapped types, and packs them into a `TypeList`. If
// `is_method` is true, tries to dereference the first argument to support smart
// pointers.
template <bool is_once, bool is_method, typename... Args>
struct ValidateUnwrappedTypeList {
  // These members are similar in intent to those in `StorageTraits`; see
  // comments there.
  using Type = TypeList<TransformToUnwrappedType<is_once, Args>...>;
  static constexpr bool value = true;
};

template <bool is_once, typename Receiver, typename... Args>
struct ValidateUnwrappedTypeList<is_once, true, Receiver, Args...> {
 private:
  using ReceiverStorageType =
      typename MethodReceiverStorage<std::decay_t<Receiver>>::Type;
  using UnwrappedReceiver =
      TransformToUnwrappedType<is_once, ReceiverStorageType>;
  using ValidatedReceiver = ValidateReceiverType<UnwrappedReceiver>;

 public:
  using Type = TypeList<typename ValidatedReceiver::Type,
                        TransformToUnwrappedType<is_once, Args>...>;
  static constexpr bool value = ValidatedReceiver::value;
};

// `IsUnretainedMayDangle` is true iff `StorageType` is marked with
// `unretained_traits::MayDangle`. Note that it is false for
// `unretained_traits::MayDangleUntriaged`.
template <typename StorageType>
inline constexpr bool IsUnretainedMayDangle = false;

template <typename T, RawPtrTraits PtrTraits>
inline constexpr bool IsUnretainedMayDangle<
    UnretainedWrapper<T, unretained_traits::MayDangle, PtrTraits>> = true;

// `UnretainedAndRawPtrHaveCompatibleTraits` is true iff `StorageType` is marked
// with `unretained_traits::MayDangle`, `FunctionParamType` is a `raw_ptr`, and
// `StorageType::GetPtrType` is the same type as `FunctionParamType`.
template <typename StorageType, typename FunctionParamType>
inline constexpr bool UnretainedAndRawPtrHaveCompatibleTraits = false;

template <typename T,
          RawPtrTraits PtrTraitsInUnretained,
          RawPtrTraits PtrTraitsInReceiver>
inline constexpr bool UnretainedAndRawPtrHaveCompatibleTraits<
    UnretainedWrapper<T, unretained_traits::MayDangle, PtrTraitsInUnretained>,
    raw_ptr<T, PtrTraitsInReceiver>> =
    std::same_as<typename UnretainedWrapper<T,
                                            unretained_traits::MayDangle,
                                            PtrTraitsInUnretained>::GetPtrType,
                 raw_ptr<T, PtrTraitsInReceiver>>;

// Helpers to make error messages slightly more readable.
template <int i>
struct BindArgument {
  template <typename ForwardingType>
  struct ForwardedAs {
    template <typename FunctorParamType>
    struct ToParamWithType {
      static constexpr bool kRawPtr = IsRawPtrV<FunctorParamType>;
      static constexpr bool kRawPtrMayBeDangling =
          IsRawPtrMayDangleV<FunctorParamType>;
      static constexpr bool kCanBeForwardedToBoundFunctor =
          std::is_convertible_v<ForwardingType, FunctorParamType>;

      // If the bound type can't be forwarded, then test if `FunctorParamType`
      // is a non-const lvalue reference and a reference to the unwrapped type
      // could have been successfully forwarded.
      static constexpr bool kIsUnwrappedForwardableNonConstReference =
          std::is_lvalue_reference_v<FunctorParamType> &&
          !std::is_const_v<std::remove_reference_t<FunctorParamType>> &&
          std::is_convertible_v<std::decay_t<ForwardingType>&,
                                FunctorParamType>;

      // Also intentionally drop the `const` qualifier from `ForwardingType`, to
      // test if it could have been successfully forwarded if `Passed()` had
      // been used.
      static constexpr bool kWouldBeForwardableWithPassed =
          std::is_convertible_v<std::decay_t<ForwardingType>&&,
                                FunctorParamType>;
    };
  };

  template <typename BoundAsType>
  struct BoundAs {
    template <typename StorageType>
    struct StoredAs {
      static constexpr bool kBindArgumentCanBeCaptured =
          std::constructible_from<StorageType, BoundAsType>;

      // If the argument can't be captured, intentionally drop the `const`
      // qualifier from `BoundAsType`, to test if it could have been
      // successfully captured if `std::move()` had been used.
      static constexpr bool kWouldBeCapturableWithStdMove =
          std::constructible_from<StorageType, std::decay_t<BoundAsType>&&>;
    };
  };

  template <typename FunctionParamType>
  struct ToParamWithType {
    template <typename StorageType>
    struct StoredAs {
      static constexpr bool kBoundPtrMayDangle =
          IsUnretainedMayDangle<StorageType>;

      static constexpr bool kMayDangleAndMayBeDanglingHaveMatchingTraits =
          UnretainedAndRawPtrHaveCompatibleTraits<StorageType,
                                                  FunctionParamType>;
    };
  };
};

// Helper to assert that parameter `i` of type `Arg` can be bound, which means:
// * `Arg` can be retained internally as `Storage`
// * `Arg` can be forwarded as `Unwrapped` to `Param`
template <int i,
          bool is_method,
          typename Arg,
          typename Storage,
          typename Unwrapped,
          typename Param>
struct ParamCanBeBound {
 private:
  using UnwrappedParam = BindArgument<i>::template ForwardedAs<
      Unwrapped>::template ToParamWithType<Param>;
  using ParamStorage = BindArgument<i>::template ToParamWithType<
      Param>::template StoredAs<Storage>;
  using BoundStorage =
      BindArgument<i>::template BoundAs<Arg>::template StoredAs<Storage>;

  template <bool v = !UnwrappedParam::kRawPtr ||
                     UnwrappedParam::kRawPtrMayBeDangling>
  struct NotRawPtr {
    static constexpr bool value = [] {
      static_assert(
          v, "Use T* or T& instead of raw_ptr<T> for function parameters, "
             "unless you must mark the parameter as MayBeDangling<T>.");
      return v;
    }();
  };

  template <bool v = !ParamStorage::kBoundPtrMayDangle ||
                     UnwrappedParam::kRawPtrMayBeDangling ||
                     // Exempt `this` pointer as it is not passed as a regular
                     // function argument.
                     (is_method && i == 0)>
  struct MayBeDanglingPtrPassedCorrectly {
    static constexpr bool value = [] {
      static_assert(v, "base::UnsafeDangling() pointers should only be passed "
                       "to parameters marked MayBeDangling<T>.");
      return v;
    }();
  };

  template <bool v =
                !UnwrappedParam::kRawPtrMayBeDangling ||
                (ParamStorage::kBoundPtrMayDangle &&
                 ParamStorage::kMayDangleAndMayBeDanglingHaveMatchingTraits)>
  struct MayDangleAndMayBeDanglingHaveMatchingTraits {
    static constexpr bool value = [] {
      static_assert(
          v, "Pointers passed to MayBeDangling<T> parameters must be created "
             "by base::UnsafeDangling() with the same RawPtrTraits.");
      return v;
    }();
  };

  // With `BindRepeating()`, there are two decision points for how to handle a
  // move-only type:
  //
  // 1. Whether the move-only argument should be moved into the internal
  //    `BindState`. Either `std::move()` or `Passed()` is sufficient to trigger
  //    move-only semantics.
  // 2. Whether or not the bound, move-only argument should be moved to the
  //    bound functor when invoked. When the argument is bound with `Passed()`,
  //    invoking the callback will destructively move the bound, move-only
  //    argument to the bound functor. In contrast, if the argument is bound
  //    with `std::move()`, `RepeatingCallback` will attempt to call the bound
  //    functor with a constant reference to the bound, move-only argument. This
  //    will fail if the bound functor accepts that argument by value, since the
  //    argument cannot be copied. It is this latter case that this
  //    assertion aims to catch.
  //
  // In contrast, `BindOnce()` only has one decision point. Once a move-only
  // type is captured by value into the internal `BindState`, the bound,
  // move-only argument will always be moved to the functor when invoked.
  // Failure to use `std::move()` will simply fail the
  // `MoveOnlyTypeMustUseStdMove` assertion below instead.
  //
  // Note: `Passed()` is a legacy of supporting move-only types when repeating
  // callbacks were the only callback type. A `RepeatingCallback` with a
  // `Passed()` argument is really a `OnceCallback` and should eventually be
  // migrated.
  template <bool v = UnwrappedParam::kCanBeForwardedToBoundFunctor ||
                     !UnwrappedParam::kWouldBeForwardableWithPassed>
  struct MoveOnlyTypeMustUseBasePassed {
    static constexpr bool value = [] {
      static_assert(v,
                    "base::BindRepeating() argument is a move-only type. Use "
                    "base::Passed() instead of std::move() to transfer "
                    "ownership from the callback to the bound functor.");
      return v;
    }();
  };

  template <bool v = UnwrappedParam::kCanBeForwardedToBoundFunctor ||
                     !UnwrappedParam::kIsUnwrappedForwardableNonConstReference>
  struct NonConstRefParamMustBeWrapped {
    static constexpr bool value = [] {
      static_assert(v,
                    "Bound argument for non-const reference parameter must be "
                    "wrapped in std::ref() or base::OwnedRef().");
      return v;
    }();
  };

  // Generic failed-to-forward message for cases that didn't match one of the
  // two assertions above.
  template <bool v = UnwrappedParam::kCanBeForwardedToBoundFunctor>
  struct CanBeForwardedToBoundFunctor {
    static constexpr bool value = [] {
      static_assert(v,
                    "Type mismatch between bound argument and bound functor's "
                    "parameter.");
      return v;
    }();
  };

  // The most common reason for failing to capture a parameter is attempting to
  // pass a move-only type as an lvalue.
  template <bool v = BoundStorage::kBindArgumentCanBeCaptured ||
                     !BoundStorage::kWouldBeCapturableWithStdMove>
  struct MoveOnlyTypeMustUseStdMove {
    static constexpr bool value = [] {
      static_assert(v,
                    "Attempting to bind a move-only type. Use std::move() to "
                    "transfer ownership to the created callback.");
      return v;
    }();
  };

  // Any other reason the parameter could not be captured.
  template <bool v = BoundStorage::kBindArgumentCanBeCaptured>
  struct BindArgumentCanBeCaptured {
    static constexpr bool value = [] {
      // In practice, failing this precondition should be rare, as the storage
      // type is deduced from the arguments passed to `Bind()`.
      static_assert(
          v, "Cannot capture argument: is the argument copyable or movable?");
      return v;
    }();
  };

 public:
  static constexpr bool value =
      std::conjunction_v<NotRawPtr<>,
                         MayBeDanglingPtrPassedCorrectly<>,
                         MayDangleAndMayBeDanglingHaveMatchingTraits<>,
                         MoveOnlyTypeMustUseBasePassed<>,
                         NonConstRefParamMustBeWrapped<>,
                         CanBeForwardedToBoundFunctor<>,
                         MoveOnlyTypeMustUseStdMove<>,
                         BindArgumentCanBeCaptured<>>;
};

// Takes three same-length `TypeList`s, and checks `ParamCanBeBound` for each
// triple.
template <bool is_method,
          typename Index,
          typename Args,
          typename UnwrappedTypeList,
          typename ParamsList>
struct ParamsCanBeBound {
  static constexpr bool value = false;
};

template <bool is_method,
          size_t... Ns,
          typename... Args,
          typename... UnwrappedTypes,
          typename... Params>
struct ParamsCanBeBound<is_method,
                        std::index_sequence<Ns...>,
                        TypeList<Args...>,
                        TypeList<UnwrappedTypes...>,
                        TypeList<Params...>> {
  static constexpr bool value =
      std::conjunction_v<ParamCanBeBound<Ns,
                                         is_method,
                                         Args,
                                         std::decay_t<Args>,
                                         UnwrappedTypes,
                                         Params>...>;
};

// Core implementation of `Bind()`, which checks common preconditions before
// returning an appropriate callback.
template <template <typename> class CallbackT>
struct BindHelper {
 private:
  static constexpr bool kIsOnce =
      is_instantiation<OnceCallback, CallbackT<void()>>;

  template <typename Functor,
            bool v = !is_instantiation<OnceCallback, std::decay_t<Functor>> ||
                     (kIsOnce && std::is_rvalue_reference_v<Functor&&> &&
                      !std::is_const_v<std::remove_reference_t<Functor>>)>
  struct OnceCallbackFunctorIsValid {
    static constexpr bool value = [] {
      if constexpr (kIsOnce) {
        static_assert(v,
                      "BindOnce() requires non-const rvalue for OnceCallback "
                      "binding, i.e. base::BindOnce(std::move(callback)).");
      } else {
        static_assert(v, "BindRepeating() cannot bind OnceCallback. Use "
                         "BindOnce() with std::move().");
      }
      return v;
    }();
  };

  template <typename... Args>
  struct NoBindArgToOnceCallbackIsBasePassed {
    static constexpr bool value = [] {
      // Can't use a defaulted template param since it can't come after `Args`.
      constexpr bool v =
          !kIsOnce ||
          (... && !is_instantiation<PassedWrapper, std::decay_t<Args>>);
      static_assert(
          v,
          "Use std::move() instead of base::Passed() with base::BindOnce().");
      return v;
    }();
  };

  template <
      typename Functor,
      bool v =
          !is_instantiation<FunctionRef, std::remove_cvref_t<Functor>> &&
          !is_instantiation<absl::FunctionRef, std::remove_cvref_t<Functor>>>
  struct NotFunctionRef {
    static constexpr bool value = [] {
      static_assert(
          v,
          "Functor may not be a FunctionRef, since that is a non-owning "
          "reference that may go out of scope before the callback executes.");
      return v;
    }();
  };

  template <typename Functor, bool v = MakeFunctorTraits<Functor>::is_stateless>
  struct IsStateless {
    static constexpr bool value = [] {
      static_assert(
          v, "Capturing lambdas and stateful functors are intentionally not "
             "supported. Use a non-capturing lambda or stateless functor (i.e. "
             "has no non-static data members) and bind arguments directly.");
      return v;
    }();
  };

  template <typename Functor, typename... Args>
  static auto BindImpl(Functor&& functor, Args&&... args) {
    // There are a lot of variables and type aliases here. An example will be
    // illustrative. Assume we call:
    // ```
    //   struct S {
    //     double f(int, const std::string&);
    //   } s;
    //   int16_t i;
    //   BindOnce(&S::f, Unretained(&s), i);
    // ```
    // This means our template params are:
    // ```
    //   template <typename> class CallbackT = OnceCallback
    //   typename Functor = double (S::*)(int, const std::string&)
    //   typename... Args =
    //       UnretainedWrapper<S, unretained_traits::MayNotDangle>, int16_t
    // ```
    // And the implementation below is effectively:
    // ```
    //   using FunctorTraits = struct {
    //     using RunType = double(S*, int, const std::string&);
    //     static constexpr bool is_method = true;
    //     static constexpr bool is_nullable = true;
    //     static constexpr bool is_callback = false;
    //     static constexpr bool is_stateless = true;
    //     ...
    //   };
    //   using ValidatedUnwrappedTypes = struct {
    //     using Type = TypeList<S*, int16_t>;
    //     static constexpr bool value = true;
    //   };
    //   using BoundArgsList = TypeList<S*, int16_t>;
    //   using RunParamsList = TypeList<S*, int, const std::string&>;
    //   using BoundParamsList = TypeList<S*, int>;
    //   using ValidatedBindState = struct {
    //     using Type =
    //         BindState<double (S::*)(int, const std::string&),
    //                   UnretainedWrapper<S, unretained_traits::MayNotDangle>,
    //                   int16_t>;
    //     static constexpr bool value = true;
    //   };
    //   if constexpr (true) {
    //     using UnboundRunType = double(const std::string&);
    //     using CallbackType = OnceCallback<double(const std::string&)>;
    //     ...
    // ```
    using FunctorTraits = MakeFunctorTraits<Functor>;
    using ValidatedUnwrappedTypes =
        ValidateUnwrappedTypeList<kIsOnce, FunctorTraits::is_method, Args&&...>;
    using BoundArgsList = TypeList<Args...>;
    using RunParamsList = ExtractArgs<typename FunctorTraits::RunType>;
    using BoundParamsList = TakeTypeListItem<sizeof...(Args), RunParamsList>;
    using ValidatedBindState =
        ValidateBindStateType<FunctorTraits::is_method, Functor, Args...>;
    // This conditional checks if each of the `args` matches to the
    // corresponding param of the target function. This check does not affect
    // the behavior of `Bind()`, but its error message should be more readable.
    if constexpr (std::conjunction_v<
                      NotFunctionRef<Functor>, IsStateless<Functor>,
                      ValidatedUnwrappedTypes,
                      ParamsCanBeBound<
                          FunctorTraits::is_method,
                          std::make_index_sequence<sizeof...(Args)>,
                          BoundArgsList, typename ValidatedUnwrappedTypes::Type,
                          BoundParamsList>,
                      ValidatedBindState>) {
      using UnboundRunType =
          MakeFunctionType<ExtractReturnType<typename FunctorTraits::RunType>,
                           DropTypeListItem<sizeof...(Args), RunParamsList>>;
      using CallbackType = CallbackT<UnboundRunType>;

      // Store the invoke func into `PolymorphicInvoke` before casting it to
      // `InvokeFuncStorage`, so that we can ensure its type matches to
      // `PolymorphicInvoke`, to which `CallbackType` will cast back.
      typename CallbackType::PolymorphicInvoke invoke_func;
      using Invoker =
          Invoker<typename ValidatedBindState::Type, UnboundRunType>;
      if constexpr (kIsOnce) {
        invoke_func = Invoker::RunOnce;
      } else {
        invoke_func = Invoker::Run;
      }

      return CallbackType(ValidatedBindState::Type::Create(
          reinterpret_cast<BindStateBase::InvokeFuncStorage>(invoke_func),
          std::forward<Functor>(functor), std::forward<Args>(args)...));
    }
  }

  // Special cases for binding to a `Callback` without extra bound arguments.

  // `OnceCallback` passed to `OnceCallback`, or `RepeatingCallback` passed to
  // `RepeatingCallback`.
  template <typename T>
    requires is_instantiation<CallbackT, T>
  static T BindImpl(T callback) {
    // Guard against null pointers accidentally ending up in posted tasks,
    // causing hard-to-debug crashes.
    CHECK(callback);
    return callback;
  }

  // `RepeatingCallback` passed to `OnceCallback`. The opposite direction is
  // intentionally not supported.
  template <typename Signature>
    requires is_instantiation<CallbackT, OnceCallback<Signature>>
  static OnceCallback<Signature> BindImpl(
      RepeatingCallback<Signature> callback) {
    return BindImpl(OnceCallback<Signature>(callback));
  }

  // Must be defined after `BindImpl()` since it refers to it.
  template <typename Functor, typename... Args>
  struct BindImplWouldSucceed {
    // Can't use a defaulted template param since it can't come after `Args`.
    //
    // Determining if `BindImpl()` would succeed is not as simple as verifying
    // any conditions it checks directly; those only control when it's safe to
    // call other methods, which in turn may fail. However, ultimately, any
    // failure will result in returning `void`, so check for a non-`void` return
    // type.
    static constexpr bool value =
        !std::same_as<void,
                      decltype(BindImpl(std::declval<Functor&&>(),
                                        std::declval<Args&&>()...))>;
  };

 public:
  template <typename Functor, typename... Args>
  static auto Bind(Functor&& functor, Args&&... args) {
    if constexpr (std::conjunction_v<
                      OnceCallbackFunctorIsValid<Functor>,
                      NoBindArgToOnceCallbackIsBasePassed<Args...>,
                      BindImplWouldSucceed<Functor, Args...>>) {
      return BindImpl(std::forward<Functor>(functor),
                      std::forward<Args>(args)...);
    } else {
      return BindFailedCheckPreviousErrors();
    }
  }
};

}  // namespace internal

// An injection point to control `this` pointer behavior on a method invocation.
// If `IsWeakReceiver<T>::value` is `true` and `T` is used as a method receiver,
// `Bind()` cancels the method invocation if the receiver tests as false.
// ```
//   struct S : SupportsWeakPtr<S> {
//     void f() {}
//   };
//
//   WeakPtr<S> weak_s = nullptr;
//   BindOnce(&S::f, weak_s).Run();  // `S::f()` is not called.
// ```
template <typename T>
struct IsWeakReceiver : std::bool_constant<is_instantiation<WeakPtr, T>> {};

template <typename T>
struct IsWeakReceiver<std::reference_wrapper<T>> : IsWeakReceiver<T> {};

// An injection point to control how objects are checked for maybe validity,
// which is an optimistic thread-safe check for full validity.
template <typename>
struct MaybeValidTraits {
  template <typename T>
  static bool MaybeValid(const T& o) {
    return o.MaybeValid();
  }
};

// An injection point to control how bound objects passed to the target
// function. `BindUnwrapTraits<>::Unwrap()` is called for each bound object
// right before the target function is invoked.
template <typename>
struct BindUnwrapTraits {
  template <typename T>
  static T&& Unwrap(T&& o) {
    return std::forward<T>(o);
  }
};

template <typename T>
  requires internal::kIsUnretainedWrapper<internal::UnretainedWrapper, T> ||
           internal::kIsUnretainedWrapper<internal::UnretainedRefWrapper, T> ||
           is_instantiation<internal::RetainedRefWrapper, T> ||
           is_instantiation<internal::OwnedWrapper, T> ||
           is_instantiation<internal::OwnedRefWrapper, T>
struct BindUnwrapTraits<T> {
  static decltype(auto) Unwrap(const T& o) { return o.get(); }
};

template <typename T>
struct BindUnwrapTraits<internal::PassedWrapper<T>> {
  static T Unwrap(const internal::PassedWrapper<T>& o) { return o.Take(); }
};

#if BUILDFLAG(IS_WIN)
template <typename T>
struct BindUnwrapTraits<Microsoft::WRL::ComPtr<T>> {
  static T* Unwrap(const Microsoft::WRL::ComPtr<T>& ptr) { return ptr.Get(); }
};
#endif

// `CallbackCancellationTraits` allows customization of `Callback`'s
// cancellation semantics. By default, callbacks are not cancellable. A
// specialization should set `is_cancellable` and implement an `IsCancelled()`
// that returns whether the callback should be cancelled, as well as a
// `MaybeValid()` that returns whether the underlying functor/object is maybe
// valid.
template <typename Functor, typename BoundArgsTuple>
struct CallbackCancellationTraits {
  static constexpr bool is_cancellable = false;
};

// Specialization for a weak receiver.
template <typename Functor, typename... BoundArgs>
  requires internal::kIsWeakMethod<internal::FunctorTraits<Functor>::is_method,
                                   BoundArgs...>
struct CallbackCancellationTraits<Functor, std::tuple<BoundArgs...>> {
  static constexpr bool is_cancellable = true;

  template <typename Receiver, typename... Args>
  static bool IsCancelled(const Functor&,
                          const Receiver& receiver,
                          const Args&...) {
    return !receiver;
  }

  template <typename Receiver, typename... Args>
  static bool MaybeValid(const Functor&,
                         const Receiver& receiver,
                         const Args&...) {
    return MaybeValidTraits<Receiver>::MaybeValid(receiver);
  }
};

// Specialization for a nested `Bind()`.
template <typename Functor, typename... BoundArgs>
  requires is_instantiation<OnceCallback, Functor> ||
           is_instantiation<RepeatingCallback, Functor>
struct CallbackCancellationTraits<Functor, std::tuple<BoundArgs...>> {
  static constexpr bool is_cancellable = true;

  static bool IsCancelled(const Functor& functor, const BoundArgs&...) {
    return functor.IsCancelled();
  }

  static bool MaybeValid(const Functor& functor, const BoundArgs&...) {
    return MaybeValidTraits<Functor>::MaybeValid(functor);
  }
};

}  // namespace base

#endif  // BASE_FUNCTIONAL_BIND_INTERNAL_H_
