// Copyright 2022 Google LLC
//
// 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
//
//      http://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.

#ifndef FUZZTEST_FUZZTEST_INTERNAL_META_H_
#define FUZZTEST_FUZZTEST_INTERNAL_META_H_

#include <array>
#include <cstddef>
#include <cstdlib>
#include <memory>
#include <optional>
#include <ostream>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>

#include "absl/numeric/int128.h"

namespace google::protobuf {
template <typename T>
struct is_proto_enum;
}  // namespace google::protobuf

namespace fuzztest::internal {

template <size_t... I, typename F>
constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
  return f(std::integral_constant<size_t, I>{}...);
}

// Invoke `f(std::integral_constant<size_t, 0>{}, ...,
//           std::integral_constant<size_t, N - 1>{});
//
// Useful with a generic lambda like:
//   ApplyIndex<N>([&](auto... I) {
//     (std::get<I>(....), ...);
//   }
// This allows users to expand an N without needing their own helper
// function/specialization generally required when working with
// std::index_sequence.
template <size_t N, typename F>
constexpr auto ApplyIndex(F f) {
  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
}

// Calls f(std::integral_constant<size_t, i>{}).
// Requires `0 <= i && i < Max`
// This function raises a runtime int into a static int. Useful for dealing with
// tuples, variants, etc.
template <size_t Max, typename F>
decltype(auto) Switch(size_t i, F f) {
  using Call = decltype(f(std::integral_constant<size_t, 0>())) (*)(F&);
  return ApplyIndex<Max>([](auto... I) {
    static constexpr Call kFuncs[] = {
        [](F& f) { return std::move(f)(decltype(I){}); }...};
    return kFuncs;
  })[i](f);
}

// Type dependent "true"/"false".
// Useful for SFINAE and static_asserts where we need a type dependent
// expression that happens to be constant.
template <typename T>
constexpr std::false_type always_false = {};
template <typename T>
constexpr std::true_type always_true = {};

// "backport" of C++20's `requires` expression.
// It can be used as:
//   if constexpr (Requires<T>([](auto x) -> decltype(x.foo()) {})) {
// with similar behavior as C++20's
//   if constexpr (requires{ t.foo(); }) {
// Much more verbose than `requires`, but still much more compact than the
// SFINAE alternative.
template <typename... T, typename F>
constexpr bool Requires(F) {
  return std::is_invocable_v<F, T...>;
}

// Simple typeid implementation that does not require RTTI.
// Only supports comparisons for equality.
using TypeId = const void*;
template <typename T>
inline constexpr TypeId type_id = &type_id<T>;

// Some simple type traits
template <typename T>
inline constexpr bool is_monostate_v = std::is_class_v<T>&& std::is_empty_v<T>&&
    std::is_default_constructible_v<T>;

template <typename T>
inline constexpr bool is_variant_v = false;

template <typename... T>
inline constexpr bool is_variant_v<std::variant<T...>> = true;

template <typename T>
inline constexpr bool is_pair_v = false;

template <typename T, typename U>
inline constexpr bool is_pair_v<std::pair<T, U>> = true;

template <typename... T>
inline constexpr bool is_tuple_v = false;

template <typename... T>
inline constexpr bool is_tuple_v<std::tuple<T...>> = true;

template <typename T>
inline constexpr bool is_array_v = false;

template <typename T, size_t N>
inline constexpr bool is_array_v<std::array<T, N>> = true;

template <typename T>
inline constexpr bool is_bitvector_v = false;

template <>
inline constexpr bool is_bitvector_v<std::vector<bool>> = true;

template <typename T>
inline constexpr bool is_vector_v = false;

template <typename T>
inline constexpr bool is_vector_v<std::vector<T>> = true;

template <typename T>
inline constexpr bool is_unique_ptr_v = false;

template <typename T>
inline constexpr bool is_unique_ptr_v<std::unique_ptr<T>> = true;

template <typename T>
inline constexpr bool is_shared_ptr_v = false;

template <typename T>
inline constexpr bool is_shared_ptr_v<std::shared_ptr<T>> = true;

template <typename T>
using MakeUnsignedT = typename std::conditional_t<
    std::is_same_v<T, absl::int128> || std::is_same_v<T, absl::uint128>,
    std::enable_if<true, absl::uint128>, std::make_unsigned<T>>::type;

// Protocol buffers are handled through duck typing to avoid a strong dependency
// on the library.
template <typename T>
constexpr bool IsProtocolBufferImpl(typename T::Message*) {
  // Check the basics:
  //  - There is a base class called Message.
  //  - It has GetReflection/GetDescriptor methods.
  //  - They interact as we expect with each other.
  //
  //  We can add more specifics if this is still too ambiguous.
  using Message = typename T::Message;
  return std::is_base_of_v<Message, T> &&
         std::is_convertible_v<const T*, const Message*> &&
         Requires<const Message*>(
             [](auto* f) -> decltype(f->GetReflection()->HasField(
                             *f, f->GetDescriptor()->field(0))) {});
}

template <typename T>
constexpr bool IsProtocolBufferImpl(...) {
  return false;
}

template <typename T>
inline constexpr bool is_protocol_buffer_v = IsProtocolBufferImpl<T>(nullptr);

template <typename T>
constexpr bool IsProtocolBufferEnumImpl(
    std::enable_if_t<google::protobuf::is_proto_enum<T>::value, bool>) {
  return true;
}

template <typename T, typename = void>
constexpr bool IsProtocolBufferEnumImpl(...) {
  return false;
}

template <typename T>
inline constexpr bool is_protocol_buffer_enum_v =
    IsProtocolBufferEnumImpl<T>(true);

template <typename T>
inline constexpr bool is_dynamic_container_v =
    Requires<T>([](auto v) -> decltype(v.insert(v.end(), *v.begin())) {});

template <typename T>
inline constexpr bool is_associative_container_v = is_dynamic_container_v<T>&&
Requires<T>([](auto v) -> decltype(v.find(
                           std::declval<typename decltype(v)::key_type>())) {});

template <typename T>
inline constexpr bool is_ostreamable_v =
    Requires<T>([](auto&& v) -> decltype(std::declval<std::ostream&>()
                                         << std::forward<decltype(v)>(v)) {});

template <typename T, typename = void>
struct is_memory_dictionary_compatible : std::false_type {};

template <typename T>
struct is_memory_dictionary_compatible<
    T, std::enable_if_t<T::is_memory_dictionary_compatible_v>>
    : std::true_type {};

// `BindAggregate` uses structured bindings to create a tuple of references to
// the fields on the input object.
// It has to be provided with the number of fields contained in the structure.
// We special case `0` because we can't do structured bindings there, and it is
// unnecessary anyway.
template <typename T>
auto BindAggregate(T&, std::integral_constant<int, 0>) {
  return std::tie();
}
// Implement the overloads from 1 to 64.
// There is no "variadic" way of doing this.
#define FUZZTEST_INTERNAL_BIND_AGGREGATE_(n, ...)                \
  template <typename T>                                          \
  auto BindAggregate(T& value, std::integral_constant<int, n>) { \
    auto& [__VA_ARGS__] = value;                                 \
    return std::tie(__VA_ARGS__);                                \
  }

FUZZTEST_INTERNAL_BIND_AGGREGATE_(1, x1);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(2, x1, x2);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(3, x1, x2, x3);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(4, x1, x2, x3, x4);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(5, x1, x2, x3, x4, x5);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(6, x1, x2, x3, x4, x5, x6);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(7, x1, x2, x3, x4, x5, x6, x7);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(8, x1, x2, x3, x4, x5, x6, x7, x8);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(9, x1, x2, x3, x4, x5, x6, x7, x8, x9);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(10, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(11, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(12, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(13, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(14, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(15, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(16, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(17, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(18, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(19, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(20, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(21, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(22, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(23, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(24, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(25, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(26, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(27, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(28, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(29, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(30, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(31, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(32, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(33, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(34, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(35, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(36, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(37, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(38, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(39, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(40, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(41, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(42, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(43, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(44, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(45, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(46, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(47, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(48, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(49, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(50, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(51, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(52, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(53, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(54, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(55, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(56, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(57, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(58, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57, x58);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(59, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57, x58, x59);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(60, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57, x58, x59, x60);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(61, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57, x58, x59, x60, x61);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(62, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57, x58, x59, x60, x61, x62);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(63, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57, x58, x59, x60, x61, x62, x63);
FUZZTEST_INTERNAL_BIND_AGGREGATE_(64, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10,
                                  x11, x12, x13, x14, x15, x16, x17, x18, x19,
                                  x20, x21, x22, x23, x24, x25, x26, x27, x28,
                                  x29, x30, x31, x32, x33, x34, x35, x36, x37,
                                  x38, x39, x40, x41, x42, x43, x44, x45, x46,
                                  x47, x48, x49, x50, x51, x52, x53, x54, x55,
                                  x56, x57, x58, x59, x60, x61, x62, x63, x64);
#undef FUZZTEST_INTERNAL_BIND_AGGREGATE_

// For N > 64, use std::get<I>.
// Some aggregate types like std::tuple provide this protocol, but so can user
// defined types.
template <typename T, int N>
auto BindAggregate(T& value, std::integral_constant<int, N>) {
  static_assert(N > 64);
  if constexpr (std::is_aggregate_v<T> &&
                !Requires<T>([](auto v) -> decltype(std::get<0>(v)) {})) {
    static_assert(always_false<T>,
                  "Aggregate types are only supported up to 64 fields.");
  }
  // For the rest use the tuple API
  return ApplyIndex<N>(
      [&](auto... I) { return std::tie(std::get<I>(value)...); });
}

// We disable `T` because `{T&&}` would work for non aggregates as a move
// construction.
template <typename T>
struct AnythingBut {
  template <typename U, std::enable_if_t<!std::is_same_v<U, T>, int> = 0>
  operator U&&() const {
    std::abort();
  }
};

// Try to call ApplyIndex from I all the way down to 0.
template <size_t I, typename F>
constexpr std::optional<int> ApplyIndexFor(F f) {
  if constexpr (ApplyIndex<I>(f)) {
    return I;
  }
  if constexpr (I == 0) {
    return std::nullopt;
  } else {
    return ApplyIndexFor<I - 1>(f);
  }
}

// Try applying aggregate initialization to `T` with different number of
// arguments. We start at 64 and go down until one works.
template <typename T>
constexpr std::optional<int> DetectBraceInitCount() {
  constexpr auto can_init_impl =
      [](auto... I) -> decltype(T{(I, AnythingBut<T>{})...}) {};
  constexpr auto can_init = [](auto... I) {
    return std::is_invocable_v<decltype(can_init_impl), decltype(I)...>;
  };
  if constexpr (!std::is_aggregate_v<T>) {
    return std::nullopt;
  }

  return ApplyIndexFor<64>(can_init);
}

// This allows us to determine whether T has a base class. If it does, it is
// initialized with a one more field than we can bind to it.
template <typename T>
struct AnythingButBaseOf {
  template <typename U, std::enable_if_t<!std::is_base_of_v<U, T>, int> = 0>
  operator U&&() const {
    std::abort();
  }
};

// Detect the number of fields bindable with `auto& [...] = t;`.
// This can be less than the number of fields used to initialize `T` if `T`
// inherits from an empty base class. Multiple inheritance is not supported.
template <typename T>
constexpr std::optional<int> DetectBindableFieldCount() {
  // Classes which inherit from a base are initialized with an extra first field
  // corresponding to the base class. We know from DetectBraceInitCount() that
  // `T` is initializable with N fields which are not a `T`. If `T` is not
  // initializable when we insist that the first field is not a base of `T`,
  // then we know that T has a base class and needs to be adjusted accordingly.
  // We don't worry about whether the potential base classes of T are empty: if
  // they are not, then binding will fail later anyways with a good error
  // message, and there is no way around this.
  constexpr std::optional<int> brace_init_count_opt = DetectBraceInitCount<T>();
  constexpr int brace_init_count = brace_init_count_opt.value_or(0);

  // Detect if the first initialization field is a base class.
  constexpr auto no_base_impl = [](auto... I)
      -> decltype(T{AnythingButBaseOf<T>{}, (I, AnythingBut<T>{})...}) {};
  constexpr auto no_base = [](auto... I) {
    return std::is_invocable_v<decltype(no_base_impl), decltype(I)...>;
  };

  if constexpr (brace_init_count < 1) {
    return brace_init_count_opt;
  } else if constexpr (ApplyIndex<brace_init_count - 1>(no_base)) {
    return brace_init_count;
  }

  // Detect if the second initialization field is a base class.
  constexpr auto no_two_bases_impl =
      [](auto... I) -> decltype(T{AnythingBut<T>{}, AnythingButBaseOf<T>{},
                                  (I, AnythingBut<T>{})...}) {};
  constexpr auto no_two_bases = [](auto... I) {
    return std::is_invocable_v<decltype(no_two_bases_impl), decltype(I)...>;
  };

  // Check for multiple inheritence. This condition also triggers if we have a
  // struct whose first field is its base class. The latter case should be
  // somewhat rare, because:
  // - We don't currently support structs with a non-empty parent class
  //   (these cannot be decomposed in `BindAggregate()`).
  // - It is rare to have a struct with a member that is an empty class, as
  //   would be the case if the parent were empty.
  if constexpr (brace_init_count >= 2) {
    static_assert(ApplyIndex<brace_init_count - 2>(no_two_bases),
                  "Multiple inheritance is not currently supported, nor are "
                  "structs whose first fields are their base class.");
  }
  // We have exactly one base class.
  return brace_init_count - 1;
}

template <typename T>
constexpr std::optional<int> DetectAggregateSize() {
  if constexpr (is_pair_v<T> || is_tuple_v<T> || is_array_v<T>) {
    return std::tuple_size_v<T>;
  } else {
    return DetectBindableFieldCount<T>();
  }
}

// Detect the number and types of the fields.
template <typename T, int N = *DetectAggregateSize<std::remove_cv_t<T>>()>
auto DetectBindAggregate(T& v) {
  return BindAggregate(v, std::integral_constant<int, N>{});
}

template <typename T>
inline constexpr bool is_bindable_aggregate_v =
    Requires<T&>([](auto& v) -> decltype(DetectBindAggregate(v)) {});

template <int I, typename T>
struct ExtractTemplateParameterImpl;

template <int I, template <typename...> class C, typename... T>
struct ExtractTemplateParameterImpl<I, C<T...>> {
  using type = std::tuple_element_t<I, std::tuple<T...>>;
};

// Evaluates to the Ith template parameter of the class template
// instantiation `T`. Eg:
//   `ExtractTemplateParameter<1, Foo<int, double, char>>`
// evaluates to `double`.
template <int I, typename T>
using ExtractTemplateParameter =
    typename ExtractTemplateParameterImpl<I, T>::type;

template <typename T>
struct DropConstImpl {
  using type = std::remove_const_t<T>;
};

template <template <typename...> class C, typename... T>
struct DropConstImpl<C<T...>> {
  using type = C<typename DropConstImpl<T>::type...>;
};

// Drop `const` recursively from class templates.
// Eg:
//   `DropConst<std::vector<std::pair<const K, std::tuple<const int>>>`
// evaluates to
//   `std::vector<std::pair<K, std::tuple<int>>>`
template <typename T>
using DropConst = typename DropConstImpl<T>::type;

// MakeDependentType<T, U...> evaluates to `T` but makes the declaration type
// dependent on templates `U...`.
// This allows delaying name lookup for the second phase when the types involved
// are fully defined.
// See https://en.cppreference.com/w/cpp/language/two-phase_lookup
template <typename T, typename... Dependent>
using MakeDependentType = std::enable_if_t<(always_true<Dependent> && ...), T>;

}  // namespace fuzztest::internal

#endif  // FUZZTEST_FUZZTEST_INTERNAL_META_H_