callback.rs

// Copyright 2019-2020 the Deno authors. All rights reserved. MIT license.

//! # Why these `impl_into_some_callback!()` macros?
//!
//! It appears that Rust is unable to use information that is available from
//! super traits for type and/or lifetime inference purposes. This causes it to
//! rejects well formed closures for no reason at all. These macros provide
//! a workaround for this issue.
//!
//! ```rust,ignore
//! // First, require that *all* implementors of `MyCallback` also implement a
//! // `Fn(...)` supertrait.
//! trait MyCallback: Sized + for<'a> Fn(&'a u32) -> &'a u32 {}
//!
//! // Povide a blanket `MyCallback` impl for all compatible types. This makes
//! // `MyCallback` essentially an alias of `Fn(&u32) -> &u32`.
//! impl<F> MyCallback for F where F: Sized + for<'a> Fn(&'a u32) -> &'a u32 {}
//!
//! // Define two functions with a parameter of the trait we just defined.
//! // One function uses the shorthand 'MyCallback', the other uses exactly the
//! // same `for<'a> Fn(...)` notation as we did when specifying the supertrait.
//! fn do_this(callback: impl MyCallback) {
//!   let val = 123u32;
//!   let _ = callback(&val);
//! }
//! fn do_that(callback: impl for<'a> Fn(&'a u32) -> &'a u32) {
//!   let val = 456u32;
//!   let _ = callback(&val);
//! }
//!
//! // Both of the above functions will accept an ordinary function (with a
//! // matching signature) as the only argument.
//! fn test_cb(a: &u32) -> &u32 { a }
//! do_this(test_cb);   // Ok!
//! do_that(test_cb);   // Ok!
//!
//! // However, when attempting to do the same with a closure, Rust loses it
//! // as it tries to reconcile the type of the closure with `impl MyCallback`.
//! do_this(|a| a);     // "Type mismatch resolving..."
//! do_that(|a| a);     // Ok!
//!
//! // Note that even when we explicitly define the closure's argument and
//! // return types, the Rust compiler still wants nothing to do with it...
//! //   ⚠ Type mismatch resolving
//! //   ⚠ `for<'a> <[closure] as FnOnce<(&'a u32,)>>::Output == &'a u32`.
//! //   ⚠ Expected bound lifetime parameter 'a, found concrete lifetime.
//! do_this(|a: &u32| -> &u32 { a });
//!
//! // The function signature used in this example is short and simple, but
//! // real world `Fn` traits tend to get long and complicated. These macros
//! // are there to make closure syntax possible without replicating the full
//! // `Fn(...)` trait definition over and over again.
//! macro_rules! impl_my_callback {
//!   () => {
//!     impl MyCallback + for<'a> Fn(&'a u32) -> &'a u32
//!   };
//! }
//!
//! // It lets us define a function with a `MyCallback` parameter as follows:
//! fn do_such(callback: impl_my_callback!()) {
//!   let val = 789u32;
//!   let _ = callback(&val);
//! }
//!
//! // And, as expected, we can pass either a function or a closure for the
//! // first argument.
//! do_such(test_cb);   // Ok!
//! do_such(|a| a);     // Ok!
//! ```

#![allow(clippy::needless_lifetimes)]
#![allow(clippy::too_many_arguments)]

use std::cell::Cell;
use std::ffi::c_void;
use std::ffi::CStr;
use std::os::raw::c_char;
use std::os::raw::c_double;
use std::os::raw::c_int;
use std::os::raw::c_uchar;
use std::slice;

use crate::function::FunctionCallbackInfo;
use crate::function::PropertyCallbackInfo;
use crate::scope::CallbackScope;
use crate::support::Opaque;
use crate::support::UnitType;
use crate::Array;
use crate::Boolean;
use crate::Context;
use crate::FunctionCallbackArguments;
use crate::HandleScope;
use crate::Integer;
use crate::Isolate;
use crate::Local;
use crate::Message;
use crate::Module;
use crate::Name;
use crate::Object;
use crate::Promise;
use crate::PromiseRejectMessage;
use crate::PropertyCallbackArguments;
use crate::ReturnValue;
use crate::ScriptOrModule;
use crate::SharedArrayBuffer;
use crate::StartupData;
use crate::String;
use crate::Value;

// Placeholder types that don't have Rust bindings yet.
#[repr(C)]
pub struct AtomicsWaitWakeHandle(Opaque);
#[repr(C)]
pub struct JitCodeEvent(Opaque);
#[repr(C)]
pub struct PropertyDescriptor(Opaque);
#[repr(C)]
pub enum AccessType {
  _TODO,
}
#[repr(C)]
pub enum AtomicsWaitEvent {
  _TODO,
}
#[repr(C)]
pub enum CrashKeyId {
  _TODO,
}
#[repr(C)]
pub enum GCCallbackFlags {
  _TODO,
}
#[repr(C)]
pub enum GCType {
  _TODO,
}
#[repr(C)]
pub enum PromiseHookType {
  _TODO,
}
#[repr(C)]
pub enum UseCounterFeature {
  _TODO,
}

/// Rust representation of a C++ `std::string`.
#[repr(C)]
pub struct CxxString(Opaque);

impl<'a> From<&'a CxxString> for &'a [u8] {
  fn from(_cxx_str: &'a CxxString) -> Self {
    unimplemented!()
  }
}

impl<'a> From<&'a CxxString> for &'a CStr {
  fn from(_cxx_str: &'a CxxString) -> Self {
    unimplemented!()
  }
}

// Notes:
// * This enum should really be #[repr(bool)] but Rust doesn't support that.
// * It must have the same layout as the C++ struct. Do not reorder fields!
#[repr(u8)]
pub enum ModifyCodeGenerationFromStringsResult<'s> {
  /// Block the codegen algorithm.
  Block,
  /// Proceed with the codegen algorithm. Otherwise, block it.
  Allow {
    /// Overwrite the original source with this string, if present.
    /// Use the original source if empty.
    modified_source: Option<Local<'s, String>>,
  },
}

// === ModuleResolveCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn module_resolve_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   specifier: v8::Local<'s, v8::String>,
///   referrer: v8::Local<'s, v8::Module>,
/// ) -> Option<v8::Local<'s, v8::Module>> {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct ModuleResolveCallback(RawModuleResolveCallback);

pub trait IntoModuleResolveCallback:
  UnitType
  + Into<ModuleResolveCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, String>,
    Local<'s, Module>,
  ) -> Option<Local<'s, Module>>
{
}

impl<F> IntoModuleResolveCallback for F where
  F: UnitType
    + Into<ModuleResolveCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, String>,
      Local<'s, Module>,
    ) -> Option<Local<'s, Module>>
{
}

#[macro_export]
macro_rules! impl_into_module_resolve_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::ModuleResolveCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::String>,
      $crate::Local<'__s, $crate::Module>,
    ) -> ::std::option::Option<$crate::Local<'__s, $crate::Module>>
  };
}

#[cfg(target_family = "unix")]
type RawModuleResolveCallback =
  for<'s> extern "C" fn(
    Local<'s, Context>,
    Local<'s, String>,
    Local<'s, Module>,
  ) -> Option<Local<'s, Module>>;

#[cfg(all(target_family = "windows", target_arch = "x86_64"))]
type RawModuleResolveCallback =
  for<'s> extern "C" fn(
    *mut Option<Local<'s, Module>>,
    Local<'s, Context>,
    Local<'s, String>,
    Local<'s, Module>,
  ) -> *mut Option<Local<'s, Module>>;

impl<F> From<F> for ModuleResolveCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, String>,
      Local<'s, Module>,
    ) -> Option<Local<'s, Module>>,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    fn signature_adapter<'s, F: IntoModuleResolveCallback>(
      context: Local<'s, Context>,
      specifier: Local<'s, String>,
      referrer: Local<'s, Module>,
    ) -> Option<Local<'s, Module>> {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, specifier, referrer)
    }

    #[cfg(target_family = "unix")]
    #[inline(always)]
    extern "C" fn abi_adapter<'s, F: IntoModuleResolveCallback>(
      context: Local<'s, Context>,
      specifier: Local<'s, String>,
      referrer: Local<'s, Module>,
    ) -> Option<Local<'s, Module>> {
      signature_adapter::<F>(context, specifier, referrer)
    }

    #[cfg(all(target_family = "windows", target_arch = "x86_64"))]
    #[inline(always)]
    extern "C" fn abi_adapter<'s, F: IntoModuleResolveCallback>(
      return_value: *mut Option<Local<'s, Module>>,
      context: Local<'s, Context>,
      specifier: Local<'s, String>,
      referrer: Local<'s, Module>,
    ) -> *mut Option<Local<'s, Module>> {
      unsafe {
        std::ptr::write(
          return_value,
          signature_adapter::<F>(context, specifier, referrer),
        );
        return_value
      }
    }

    Self(abi_adapter::<F>)
  }
}

#[cfg(test)]
fn mock_module_resolve_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _specifier: Local<'s, String>,
  _referrer: Local<'s, Module>,
) -> Option<Local<'s, Module>> {
  unimplemented!()
}

#[test]
fn module_resolve_callback_as_type_param() {
  fn pass_as_type_param<F: IntoModuleResolveCallback>(
    _: F,
  ) -> ModuleResolveCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_module_resolve_callback);
}

#[test]
fn module_resolve_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<ModuleResolveCallback>,
  ) -> ModuleResolveCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_module_resolve_callback);
}

#[test]
fn module_resolve_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_module_resolve_callback!(),
  ) -> ModuleResolveCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_module_resolve_callback);
  let _ =
    pass_as_impl_into_macro(|_scope, _specifier, _referrer| unimplemented!());
}

// === SyntheticModuleEvaluationSteps ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn synthetic_module_evaluation_steps_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   module: v8::Local<'s, v8::Module>,
/// ) -> Option<v8::Local<'s, v8::Value>> {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct SyntheticModuleEvaluationSteps(RawSyntheticModuleEvaluationSteps);

pub trait IntoSyntheticModuleEvaluationSteps:
  UnitType
  + Into<SyntheticModuleEvaluationSteps>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Module>,
  ) -> Option<Local<'s, Value>>
{
}

impl<F> IntoSyntheticModuleEvaluationSteps for F where
  F: UnitType
    + Into<SyntheticModuleEvaluationSteps>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Module>,
    ) -> Option<Local<'s, Value>>
{
}

#[macro_export]
macro_rules! impl_into_synthetic_module_evaluation_steps {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::SyntheticModuleEvaluationSteps>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Module>,
    ) -> ::std::option::Option<$crate::Local<'__s, $crate::Value>>
  };
}

#[cfg(target_family = "unix")]
type RawSyntheticModuleEvaluationSteps =
  for<'s> extern "C" fn(
    Local<'s, Context>,
    Local<'s, Module>,
  ) -> Option<Local<'s, Value>>;

#[cfg(all(target_family = "windows", target_arch = "x86_64"))]
type RawSyntheticModuleEvaluationSteps =
  for<'s> extern "C" fn(
    *mut Option<Local<'s, Value>>,
    Local<'s, Context>,
    Local<'s, Module>,
  ) -> *mut Option<Local<'s, Value>>;

impl<F> From<F> for SyntheticModuleEvaluationSteps
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Module>,
    ) -> Option<Local<'s, Value>>,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    fn signature_adapter<'s, F: IntoSyntheticModuleEvaluationSteps>(
      context: Local<'s, Context>,
      module: Local<'s, Module>,
    ) -> Option<Local<'s, Value>> {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, module)
    }

    #[cfg(target_family = "unix")]
    #[inline(always)]
    extern "C" fn abi_adapter<'s, F: IntoSyntheticModuleEvaluationSteps>(
      context: Local<'s, Context>,
      module: Local<'s, Module>,
    ) -> Option<Local<'s, Value>> {
      signature_adapter::<F>(context, module)
    }

    #[cfg(all(target_family = "windows", target_arch = "x86_64"))]
    #[inline(always)]
    extern "C" fn abi_adapter<'s, F: IntoSyntheticModuleEvaluationSteps>(
      return_value: *mut Option<Local<'s, Value>>,
      context: Local<'s, Context>,
      module: Local<'s, Module>,
    ) -> *mut Option<Local<'s, Value>> {
      unsafe {
        std::ptr::write(return_value, signature_adapter::<F>(context, module));
        return_value
      }
    }

    Self(abi_adapter::<F>)
  }
}

#[cfg(test)]
fn mock_synthetic_module_evaluation_steps<'s>(
  _scope: &mut HandleScope<'s>,
  _module: Local<'s, Module>,
) -> Option<Local<'s, Value>> {
  unimplemented!()
}

#[test]
fn synthetic_module_evaluation_steps_as_type_param() {
  fn pass_as_type_param<F: IntoSyntheticModuleEvaluationSteps>(
    _: F,
  ) -> SyntheticModuleEvaluationSteps {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_synthetic_module_evaluation_steps);
}

#[test]
fn synthetic_module_evaluation_steps_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<SyntheticModuleEvaluationSteps>,
  ) -> SyntheticModuleEvaluationSteps {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_synthetic_module_evaluation_steps);
}

#[test]
fn synthetic_module_evaluation_steps_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_synthetic_module_evaluation_steps!(),
  ) -> SyntheticModuleEvaluationSteps {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_synthetic_module_evaluation_steps);
  let _ = pass_as_impl_into_macro(|_scope, _module| unimplemented!());
}

/// Accessor[Getter|Setter] are used as callback functions when
/// setting|getting a particular property. See Object and ObjectTemplate's
/// method SetAccessor.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn accessor_getter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::String>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AccessorGetterCallback(RawAccessorGetterCallback);

pub trait IntoAccessorGetterCallback:
  UnitType
  + Into<AccessorGetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, String>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoAccessorGetterCallback for F where
  F: UnitType
    + Into<AccessorGetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, String>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_accessor_getter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AccessorGetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::String>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawAccessorGetterCallback =
  for<'s> extern "C" fn(Local<'s, String>, *const PropertyCallbackInfo);

impl<F> From<F> for AccessorGetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, String>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAccessorGetterCallback>(
      property: Local<'s, String>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, property, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_accessor_getter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, String>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn accessor_getter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAccessorGetterCallback>(
    _: F,
  ) -> AccessorGetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_accessor_getter_callback);
}

#[test]
fn accessor_getter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AccessorGetterCallback>,
  ) -> AccessorGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_accessor_getter_callback);
}

#[test]
fn accessor_getter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_accessor_getter_callback!(),
  ) -> AccessorGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_accessor_getter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _arguments, _return_value| unimplemented!(),
  );
}

// === AccessorNameGetterCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn accessor_name_getter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AccessorNameGetterCallback(RawAccessorNameGetterCallback);

pub trait IntoAccessorNameGetterCallback:
  UnitType
  + Into<AccessorNameGetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoAccessorNameGetterCallback for F where
  F: UnitType
    + Into<AccessorNameGetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_accessor_name_getter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AccessorNameGetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawAccessorNameGetterCallback =
  for<'s> extern "C" fn(Local<'s, Name>, *const PropertyCallbackInfo);

impl<F> From<F> for AccessorNameGetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAccessorNameGetterCallback>(
      property: Local<'s, Name>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, property, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_accessor_name_getter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn accessor_name_getter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAccessorNameGetterCallback>(
    _: F,
  ) -> AccessorNameGetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_accessor_name_getter_callback);
}

#[test]
fn accessor_name_getter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AccessorNameGetterCallback>,
  ) -> AccessorNameGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_accessor_name_getter_callback);
}

#[test]
fn accessor_name_getter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_accessor_name_getter_callback!(),
  ) -> AccessorNameGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_accessor_name_getter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _arguments, _return_value| unimplemented!(),
  );
}

// === AccessorSetterCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn accessor_setter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::String>,
///   value: v8::Local<'s, v8::Value>,
///   arguments: v8::PropertyCallbackArguments<'s>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AccessorSetterCallback(RawAccessorSetterCallback);

pub trait IntoAccessorSetterCallback:
  UnitType
  + Into<AccessorSetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, String>,
    Local<'s, Value>,
    PropertyCallbackArguments<'s>,
  )
{
}

impl<F> IntoAccessorSetterCallback for F where
  F: UnitType
    + Into<AccessorSetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, String>,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
    )
{
}

#[macro_export]
macro_rules! impl_into_accessor_setter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AccessorSetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::String>,
      $crate::Local<'__s, $crate::Value>,
      $crate::PropertyCallbackArguments<'__s>,
    )
  };
}

type RawAccessorSetterCallback = for<'s> extern "C" fn(
  Local<'s, String>,
  Local<'s, Value>,
  *const PropertyCallbackInfo,
);

impl<F> From<F> for AccessorSetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, String>,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAccessorSetterCallback>(
      property: Local<'s, String>,
      value: Local<'s, Value>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      (F::get())(scope, property, value, arguments)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_accessor_setter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, String>,
  _value: Local<'s, Value>,
  _arguments: PropertyCallbackArguments<'s>,
) {
  unimplemented!()
}

#[test]
fn accessor_setter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAccessorSetterCallback>(
    _: F,
  ) -> AccessorSetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_accessor_setter_callback);
}

#[test]
fn accessor_setter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AccessorSetterCallback>,
  ) -> AccessorSetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_accessor_setter_callback);
}

#[test]
fn accessor_setter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_accessor_setter_callback!(),
  ) -> AccessorSetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_accessor_setter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _value, _arguments| unimplemented!(),
  );
}

// === AccessorNameSetterCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn accessor_name_setter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   value: v8::Local<'s, v8::Value>,
///   arguments: v8::PropertyCallbackArguments<'s>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AccessorNameSetterCallback(RawAccessorNameSetterCallback);

pub trait IntoAccessorNameSetterCallback:
  UnitType
  + Into<AccessorNameSetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    Local<'s, Value>,
    PropertyCallbackArguments<'s>,
  )
{
}

impl<F> IntoAccessorNameSetterCallback for F where
  F: UnitType
    + Into<AccessorNameSetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
    )
{
}

#[macro_export]
macro_rules! impl_into_accessor_name_setter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AccessorNameSetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      $crate::Local<'__s, $crate::Value>,
      $crate::PropertyCallbackArguments<'__s>,
    )
  };
}

type RawAccessorNameSetterCallback = for<'s> extern "C" fn(
  Local<'s, Name>,
  Local<'s, Value>,
  *const PropertyCallbackInfo,
);

impl<F> From<F> for AccessorNameSetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAccessorNameSetterCallback>(
      property: Local<'s, Name>,
      value: Local<'s, Value>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      (F::get())(scope, property, value, arguments)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_accessor_name_setter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _value: Local<'s, Value>,
  _arguments: PropertyCallbackArguments<'s>,
) {
  unimplemented!()
}

#[test]
fn accessor_name_setter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAccessorNameSetterCallback>(
    _: F,
  ) -> AccessorNameSetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_accessor_name_setter_callback);
}

#[test]
fn accessor_name_setter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AccessorNameSetterCallback>,
  ) -> AccessorNameSetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_accessor_name_setter_callback);
}

#[test]
fn accessor_name_setter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_accessor_name_setter_callback!(),
  ) -> AccessorNameSetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_accessor_name_setter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _value, _arguments| unimplemented!(),
  );
}

// === FunctionCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn function_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   arguments: v8::FunctionCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct FunctionCallback(RawFunctionCallback);

pub trait IntoFunctionCallback:
  UnitType
  + Into<FunctionCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    FunctionCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoFunctionCallback for F where
  F: UnitType
    + Into<FunctionCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_function_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::FunctionCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::FunctionCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawFunctionCallback = extern "C" fn(*const FunctionCallbackInfo);

impl<F> From<F> for FunctionCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoFunctionCallback>(
      info: *const FunctionCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        FunctionCallbackArguments::from_function_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_function_callback_info(info);
      (F::get())(scope, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_function_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _arguments: FunctionCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn function_callback_as_type_param() {
  fn pass_as_type_param<F: IntoFunctionCallback>(_: F) -> FunctionCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_function_callback);
}

#[test]
fn function_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<FunctionCallback>,
  ) -> FunctionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_function_callback);
}

#[test]
fn function_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_function_callback!(),
  ) -> FunctionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_function_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _arguments, _return_value| unimplemented!(),
  );
}

/// This callback is used only if the memory block for a BackingStore cannot be
/// allocated with an ArrayBuffer::Allocator. In such cases the destructor of
/// the BackingStore invokes the callback to free the memory block.
///
/// ## Example
///
/// ```
/// fn backing_store_deleter_callback_example(
///   data: &mut [u8],
///   deleter_data: *mut (),
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct BackingStoreDeleterCallback(RawBackingStoreDeleterCallback);

pub trait IntoBackingStoreDeleterCallback:
  UnitType + Into<BackingStoreDeleterCallback> + FnOnce(&mut [u8], *mut ())
{
}

impl<F> IntoBackingStoreDeleterCallback for F where
  F: UnitType + Into<BackingStoreDeleterCallback> + FnOnce(&mut [u8], *mut ())
{
}

#[macro_export]
macro_rules! impl_into_backing_store_deleter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::BackingStoreDeleterCallback>
    + ::std::ops::FnOnce(
      &mut [u8],
      *mut (),
    )
  };
}

type RawBackingStoreDeleterCallback =
  extern "C" fn(*mut c_void, usize, *mut c_void);

impl<F> From<F> for BackingStoreDeleterCallback
where
  F: UnitType + FnOnce(&mut [u8], *mut ()),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoBackingStoreDeleterCallback>(
      data: *mut c_void,
      length: usize,
      deleter_data: *mut c_void,
    ) {
      let data = unsafe { slice::from_raw_parts_mut(data as *mut u8, length) };
      let deleter_data = deleter_data as *mut ();
      (F::get())(data, deleter_data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_backing_store_deleter_callback(
  _data: &mut [u8],
  _deleter_data: *mut (),
) {
  unimplemented!()
}

#[test]
fn backing_store_deleter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoBackingStoreDeleterCallback>(
    _: F,
  ) -> BackingStoreDeleterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_backing_store_deleter_callback);
}

#[test]
fn backing_store_deleter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<BackingStoreDeleterCallback>,
  ) -> BackingStoreDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_backing_store_deleter_callback);
}

#[test]
fn backing_store_deleter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_backing_store_deleter_callback!(),
  ) -> BackingStoreDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_backing_store_deleter_callback);
  let _ = pass_as_impl_into_macro(|_data, _deleter_data| unimplemented!());
}

// === ArrayBufferContentsDeleterCallback ===

/// ## Example
///
/// ```
/// fn array_buffer_contents_deleter_callback_example(
///   buffer: &mut [u8],
///   info: *mut (),
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct ArrayBufferContentsDeleterCallback(
  RawArrayBufferContentsDeleterCallback,
);

pub trait IntoArrayBufferContentsDeleterCallback:
  UnitType + Into<ArrayBufferContentsDeleterCallback> + FnOnce(&mut [u8], *mut ())
{
}

impl<F> IntoArrayBufferContentsDeleterCallback for F where
  F: UnitType
    + Into<ArrayBufferContentsDeleterCallback>
    + FnOnce(&mut [u8], *mut ())
{
}

#[macro_export]
macro_rules! impl_into_array_buffer_contents_deleter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::ArrayBufferContentsDeleterCallback>
    + ::std::ops::FnOnce(
      &mut [u8],
      *mut (),
    )
  };
}

type RawArrayBufferContentsDeleterCallback =
  extern "C" fn(*mut c_void, usize, *mut c_void);

impl<F> From<F> for ArrayBufferContentsDeleterCallback
where
  F: UnitType + FnOnce(&mut [u8], *mut ()),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoArrayBufferContentsDeleterCallback>(
      buffer: *mut c_void,
      length: usize,
      info: *mut c_void,
    ) {
      let buffer =
        unsafe { slice::from_raw_parts_mut(buffer as *mut u8, length) };
      let info = info as *mut ();
      (F::get())(buffer, info)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_array_buffer_contents_deleter_callback(
  _buffer: &mut [u8],
  _info: *mut (),
) {
  unimplemented!()
}

#[test]
fn array_buffer_contents_deleter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoArrayBufferContentsDeleterCallback>(
    _: F,
  ) -> ArrayBufferContentsDeleterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_array_buffer_contents_deleter_callback);
}

#[test]
fn array_buffer_contents_deleter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<ArrayBufferContentsDeleterCallback>,
  ) -> ArrayBufferContentsDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_array_buffer_contents_deleter_callback);
}

#[test]
fn array_buffer_contents_deleter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_array_buffer_contents_deleter_callback!(),
  ) -> ArrayBufferContentsDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_array_buffer_contents_deleter_callback);
  let _ = pass_as_impl_into_macro(|_buffer, _info| unimplemented!());
}

// === SharedArrayBufferContentsDeleterCallback ===

/// ## Example
///
/// ```
/// fn shared_array_buffer_contents_deleter_callback_example(
///   buffer: &mut [u8],
///   info: *mut (),
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct SharedArrayBufferContentsDeleterCallback(
  RawSharedArrayBufferContentsDeleterCallback,
);

pub trait IntoSharedArrayBufferContentsDeleterCallback:
  UnitType
  + Into<SharedArrayBufferContentsDeleterCallback>
  + FnOnce(&mut [u8], *mut ())
{
}

impl<F> IntoSharedArrayBufferContentsDeleterCallback for F where
  F: UnitType
    + Into<SharedArrayBufferContentsDeleterCallback>
    + FnOnce(&mut [u8], *mut ())
{
}

#[macro_export]
macro_rules! impl_into_shared_array_buffer_contents_deleter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::SharedArrayBufferContentsDeleterCallback>
    + ::std::ops::FnOnce(
      &mut [u8],
      *mut (),
    )
  };
}

type RawSharedArrayBufferContentsDeleterCallback =
  extern "C" fn(*mut c_void, usize, *mut c_void);

impl<F> From<F> for SharedArrayBufferContentsDeleterCallback
where
  F: UnitType + FnOnce(&mut [u8], *mut ()),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoSharedArrayBufferContentsDeleterCallback>(
      buffer: *mut c_void,
      length: usize,
      info: *mut c_void,
    ) {
      let buffer =
        unsafe { slice::from_raw_parts_mut(buffer as *mut u8, length) };
      let info = info as *mut ();
      (F::get())(buffer, info)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_shared_array_buffer_contents_deleter_callback(
  _buffer: &mut [u8],
  _info: *mut (),
) {
  unimplemented!()
}

#[test]
fn shared_array_buffer_contents_deleter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoSharedArrayBufferContentsDeleterCallback>(
    _: F,
  ) -> SharedArrayBufferContentsDeleterCallback {
    F::get().into()
  }
  let _ =
    pass_as_type_param(mock_shared_array_buffer_contents_deleter_callback);
}

#[test]
fn shared_array_buffer_contents_deleter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<SharedArrayBufferContentsDeleterCallback>,
  ) -> SharedArrayBufferContentsDeleterCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_trait(mock_shared_array_buffer_contents_deleter_callback);
}

#[test]
fn shared_array_buffer_contents_deleter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_shared_array_buffer_contents_deleter_callback!(),
  ) -> SharedArrayBufferContentsDeleterCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_macro(mock_shared_array_buffer_contents_deleter_callback);
  let _ = pass_as_impl_into_macro(|_buffer, _info| unimplemented!());
}

/// Interceptor for get requests on an object.
///
/// Use `info.GetReturnValue().Set()` to set the return value of the
/// intercepted get request.
///
/// \param property The name of the property for which the request was
/// intercepted.
/// \param info Information about the intercepted request, such as
/// isolate, receiver, return value, or whether running in `'use strict`' mode.
/// See `PropertyCallbackInfo`.
///
/// ```ignore
///  void GetterCallback(
///    Local<Name> name,
///    const v8::PropertyCallbackInfo<v8::Value>& info) {
///      info.GetReturnValue().Set(v8_num(42));
///  }
///
///  v8::Local<v8::FunctionTemplate> templ =
///      v8::FunctionTemplate::New(isolate);
///  templ->InstanceTemplate()->SetHandler(
///      v8::NamedPropertyHandlerConfiguration(GetterCallback));
///  LocalContext env;
///  env->Global()
///      ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())
///                                             .ToLocalChecked()
///                                             ->NewInstance(env.local())
///                                             .ToLocalChecked())
///      .FromJust();
///  v8::Local<v8::Value> result = CompileRun("obj.a = 17; obj.a");
///  CHECK(v8_num(42)->Equals(env.local(), result).FromJust());
/// ```
///
/// See also `ObjectTemplate::SetHandler`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn generic_named_property_getter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GenericNamedPropertyGetterCallback(
  RawGenericNamedPropertyGetterCallback,
);

pub trait IntoGenericNamedPropertyGetterCallback:
  UnitType
  + Into<GenericNamedPropertyGetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoGenericNamedPropertyGetterCallback for F where
  F: UnitType
    + Into<GenericNamedPropertyGetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_generic_named_property_getter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GenericNamedPropertyGetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawGenericNamedPropertyGetterCallback =
  for<'s> extern "C" fn(Local<'s, Name>, *const PropertyCallbackInfo);

impl<F> From<F> for GenericNamedPropertyGetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoGenericNamedPropertyGetterCallback>(
      property: Local<'s, Name>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, property, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_generic_named_property_getter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn generic_named_property_getter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGenericNamedPropertyGetterCallback>(
    _: F,
  ) -> GenericNamedPropertyGetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_generic_named_property_getter_callback);
}

#[test]
fn generic_named_property_getter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GenericNamedPropertyGetterCallback>,
  ) -> GenericNamedPropertyGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_generic_named_property_getter_callback);
}

#[test]
fn generic_named_property_getter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_generic_named_property_getter_callback!(),
  ) -> GenericNamedPropertyGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_generic_named_property_getter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _arguments, _return_value| unimplemented!(),
  );
}

/// Interceptor for set requests on an object.
///
/// Use `info.GetReturnValue()` to indicate whether the request was intercepted
/// or not. If the setter successfully intercepts the request, i.e., if the
/// request should not be further executed, call
/// `info.GetReturnValue().Set(value)`. If the setter
/// did not intercept the request, i.e., if the request should be handled as
/// if no interceptor is present, do not not call `Set()`.
///
/// \param property The name of the property for which the request was
/// intercepted.
/// \param value The value which the property will have if the request
/// is not intercepted.
/// \param info Information about the intercepted request, such as
/// isolate, receiver, return value, or whether running in `'use strict'` mode.
/// See `PropertyCallbackInfo`.
///
/// See also
/// `ObjectTemplate::SetHandler.`
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn generic_named_property_setter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   value: v8::Local<'s, v8::Value>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GenericNamedPropertySetterCallback(
  RawGenericNamedPropertySetterCallback,
);

pub trait IntoGenericNamedPropertySetterCallback:
  UnitType
  + Into<GenericNamedPropertySetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    Local<'s, Value>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoGenericNamedPropertySetterCallback for F where
  F: UnitType
    + Into<GenericNamedPropertySetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_generic_named_property_setter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GenericNamedPropertySetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      $crate::Local<'__s, $crate::Value>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawGenericNamedPropertySetterCallback = for<'s> extern "C" fn(
  Local<'s, Name>,
  Local<'s, Value>,
  *const PropertyCallbackInfo,
);

impl<F> From<F> for GenericNamedPropertySetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoGenericNamedPropertySetterCallback>(
      property: Local<'s, Name>,
      value: Local<'s, Value>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, property, value, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_generic_named_property_setter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _value: Local<'s, Value>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn generic_named_property_setter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGenericNamedPropertySetterCallback>(
    _: F,
  ) -> GenericNamedPropertySetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_generic_named_property_setter_callback);
}

#[test]
fn generic_named_property_setter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GenericNamedPropertySetterCallback>,
  ) -> GenericNamedPropertySetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_generic_named_property_setter_callback);
}

#[test]
fn generic_named_property_setter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_generic_named_property_setter_callback!(),
  ) -> GenericNamedPropertySetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_generic_named_property_setter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _value, _arguments, _return_value| unimplemented!(),
  );
}

/// Intercepts all requests that query the attributes of the
/// property, e.g., getOwnPropertyDescriptor(), propertyIsEnumerable(), and
/// defineProperty().
///
/// Use `info.GetReturnValue().Set(value)` to set the property attributes. The
/// value is an integer encoding a `v8::PropertyAttribute`.
///
/// \param property The name of the property for which the request was
/// intercepted.
/// \param info Information about the intercepted request, such as
/// isolate, receiver, return value, or whether running in `'use strict'` mode.
/// See `PropertyCallbackInfo`.
///
/// \note Some functions query the property attributes internally, even though
/// they do not return the attributes. For example, `hasOwnProperty()` can
/// trigger this interceptor depending on the state of the object.
///
/// See also
/// `ObjectTemplate::SetHandler.`
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn generic_named_property_query_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Integer>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GenericNamedPropertyQueryCallback(
  RawGenericNamedPropertyQueryCallback,
);

pub trait IntoGenericNamedPropertyQueryCallback:
  UnitType
  + Into<GenericNamedPropertyQueryCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Integer>,
  )
{
}

impl<F> IntoGenericNamedPropertyQueryCallback for F where
  F: UnitType
    + Into<GenericNamedPropertyQueryCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Integer>,
    )
{
}

#[macro_export]
macro_rules! impl_into_generic_named_property_query_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GenericNamedPropertyQueryCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Integer>,
    )
  };
}

type RawGenericNamedPropertyQueryCallback =
  for<'s> extern "C" fn(Local<'s, Name>, *const PropertyCallbackInfo);

impl<F> From<F> for GenericNamedPropertyQueryCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Integer>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoGenericNamedPropertyQueryCallback>(
      property: Local<'s, Name>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Integer>::from_property_callback_info(info);
      (F::get())(scope, property, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_generic_named_property_query_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Integer>,
) {
  unimplemented!()
}

#[test]
fn generic_named_property_query_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGenericNamedPropertyQueryCallback>(
    _: F,
  ) -> GenericNamedPropertyQueryCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_generic_named_property_query_callback);
}

#[test]
fn generic_named_property_query_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GenericNamedPropertyQueryCallback>,
  ) -> GenericNamedPropertyQueryCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_generic_named_property_query_callback);
}

#[test]
fn generic_named_property_query_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_generic_named_property_query_callback!(),
  ) -> GenericNamedPropertyQueryCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_generic_named_property_query_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _arguments, _return_value| unimplemented!(),
  );
}

/// Interceptor for delete requests on an object.
///
/// Use `info.GetReturnValue()` to indicate whether the request was intercepted
/// or not. If the deleter successfully intercepts the request, i.e., if the
/// request should not be further executed, call
/// `info.GetReturnValue().Set(value)` with a boolean `value`. The `value` is
/// used as the return value of `delete`.
///
/// \param property The name of the property for which the request was
/// intercepted.
/// \param info Information about the intercepted request, such as
/// isolate, receiver, return value, or whether running in `'use strict'` mode.
/// See `PropertyCallbackInfo`.
///
/// \note If you need to mimic the behavior of `delete`, i.e., throw in strict
/// mode instead of returning false, use `info.ShouldThrowOnError()` to determine
/// if you are in strict mode.
///
/// See also `ObjectTemplate::SetHandler.`
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn generic_named_property_deleter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Boolean>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GenericNamedPropertyDeleterCallback(
  RawGenericNamedPropertyDeleterCallback,
);

pub trait IntoGenericNamedPropertyDeleterCallback:
  UnitType
  + Into<GenericNamedPropertyDeleterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Boolean>,
  )
{
}

impl<F> IntoGenericNamedPropertyDeleterCallback for F where
  F: UnitType
    + Into<GenericNamedPropertyDeleterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Boolean>,
    )
{
}

#[macro_export]
macro_rules! impl_into_generic_named_property_deleter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GenericNamedPropertyDeleterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Boolean>,
    )
  };
}

type RawGenericNamedPropertyDeleterCallback =
  for<'s> extern "C" fn(Local<'s, Name>, *const PropertyCallbackInfo);

impl<F> From<F> for GenericNamedPropertyDeleterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Boolean>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoGenericNamedPropertyDeleterCallback>(
      property: Local<'s, Name>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Boolean>::from_property_callback_info(info);
      (F::get())(scope, property, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_generic_named_property_deleter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Boolean>,
) {
  unimplemented!()
}

#[test]
fn generic_named_property_deleter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGenericNamedPropertyDeleterCallback>(
    _: F,
  ) -> GenericNamedPropertyDeleterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_generic_named_property_deleter_callback);
}

#[test]
fn generic_named_property_deleter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GenericNamedPropertyDeleterCallback>,
  ) -> GenericNamedPropertyDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_generic_named_property_deleter_callback);
}

#[test]
fn generic_named_property_deleter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_generic_named_property_deleter_callback!(),
  ) -> GenericNamedPropertyDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_generic_named_property_deleter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _arguments, _return_value| unimplemented!(),
  );
}

/// Returns an array containing the names of the properties the named
/// property getter intercepts.
///
/// Note: The values in the array must be of type v8::Name.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn generic_named_property_enumerator_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Array>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GenericNamedPropertyEnumeratorCallback(
  RawGenericNamedPropertyEnumeratorCallback,
);

pub trait IntoGenericNamedPropertyEnumeratorCallback:
  UnitType
  + Into<GenericNamedPropertyEnumeratorCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Array>,
  )
{
}

impl<F> IntoGenericNamedPropertyEnumeratorCallback for F where
  F: UnitType
    + Into<GenericNamedPropertyEnumeratorCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Array>,
    )
{
}

#[macro_export]
macro_rules! impl_into_generic_named_property_enumerator_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GenericNamedPropertyEnumeratorCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Array>,
    )
  };
}

type RawGenericNamedPropertyEnumeratorCallback =
  extern "C" fn(*const PropertyCallbackInfo);

impl<F> From<F> for GenericNamedPropertyEnumeratorCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Array>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoGenericNamedPropertyEnumeratorCallback>(
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Array>::from_property_callback_info(info);
      (F::get())(scope, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_generic_named_property_enumerator_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Array>,
) {
  unimplemented!()
}

#[test]
fn generic_named_property_enumerator_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGenericNamedPropertyEnumeratorCallback>(
    _: F,
  ) -> GenericNamedPropertyEnumeratorCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_generic_named_property_enumerator_callback);
}

#[test]
fn generic_named_property_enumerator_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GenericNamedPropertyEnumeratorCallback>,
  ) -> GenericNamedPropertyEnumeratorCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_trait(mock_generic_named_property_enumerator_callback);
}

#[test]
fn generic_named_property_enumerator_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_generic_named_property_enumerator_callback!(),
  ) -> GenericNamedPropertyEnumeratorCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_macro(mock_generic_named_property_enumerator_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _arguments, _return_value| unimplemented!(),
  );
}

/// Interceptor for defineProperty requests on an object.
///
/// Use `info.GetReturnValue()` to indicate whether the request was intercepted
/// or not. If the definer successfully intercepts the request, i.e., if the
/// request should not be further executed, call
/// `info.GetReturnValue().Set(value)`. If the definer
/// did not intercept the request, i.e., if the request should be handled as
/// if no interceptor is present, do not not call `Set()`.
///
/// \param property The name of the property for which the request was
/// intercepted.
/// \param desc The property descriptor which is used to define the
/// property if the request is not intercepted.
/// \param info Information about the intercepted request, such as
/// isolate, receiver, return value, or whether running in `'use strict'` mode.
/// See `PropertyCallbackInfo`.
///
/// See also `ObjectTemplate::SetHandler`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn generic_named_property_definer_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   desc: &v8::PropertyDescriptor,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GenericNamedPropertyDefinerCallback(
  RawGenericNamedPropertyDefinerCallback,
);

pub trait IntoGenericNamedPropertyDefinerCallback:
  UnitType
  + Into<GenericNamedPropertyDefinerCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    &PropertyDescriptor,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoGenericNamedPropertyDefinerCallback for F where
  F: UnitType
    + Into<GenericNamedPropertyDefinerCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      &PropertyDescriptor,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_generic_named_property_definer_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GenericNamedPropertyDefinerCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      &$crate::PropertyDescriptor,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawGenericNamedPropertyDefinerCallback = for<'s> extern "C" fn(
  Local<'s, Name>,
  *const PropertyDescriptor,
  *const PropertyCallbackInfo,
);

impl<F> From<F> for GenericNamedPropertyDefinerCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      &PropertyDescriptor,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoGenericNamedPropertyDefinerCallback>(
      property: Local<'s, Name>,
      desc: *const PropertyDescriptor,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let desc = unsafe { &*desc };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, property, desc, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_generic_named_property_definer_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _desc: &PropertyDescriptor,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn generic_named_property_definer_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGenericNamedPropertyDefinerCallback>(
    _: F,
  ) -> GenericNamedPropertyDefinerCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_generic_named_property_definer_callback);
}

#[test]
fn generic_named_property_definer_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GenericNamedPropertyDefinerCallback>,
  ) -> GenericNamedPropertyDefinerCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_generic_named_property_definer_callback);
}

#[test]
fn generic_named_property_definer_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_generic_named_property_definer_callback!(),
  ) -> GenericNamedPropertyDefinerCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_generic_named_property_definer_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _desc, _arguments, _return_value| unimplemented!(),
  );
}

/// Interceptor for getOwnPropertyDescriptor requests on an object.
///
/// Use `info.GetReturnValue().Set()` to set the return value of the
/// intercepted request. The return value must be an object that
/// can be converted to a PropertyDescriptor, e.g., a `v8::value` returned from
/// `v8::Object::getOwnPropertyDescriptor`.
///
/// \param property The name of the property for which the request was
/// intercepted.
/// \info Information about the intercepted request, such as
/// isolate, receiver, return value, or whether running in `'use strict'` mode.
/// See `PropertyCallbackInfo`.
///
/// \note If GetOwnPropertyDescriptor is intercepted, it will
/// always return true, i.e., indicate that the property was found.
///
/// See also `ObjectTemplate::SetHandler`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn generic_named_property_descriptor_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   property: v8::Local<'s, v8::Name>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GenericNamedPropertyDescriptorCallback(
  RawGenericNamedPropertyDescriptorCallback,
);

pub trait IntoGenericNamedPropertyDescriptorCallback:
  UnitType
  + Into<GenericNamedPropertyDescriptorCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Name>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoGenericNamedPropertyDescriptorCallback for F where
  F: UnitType
    + Into<GenericNamedPropertyDescriptorCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_generic_named_property_descriptor_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GenericNamedPropertyDescriptorCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Name>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawGenericNamedPropertyDescriptorCallback =
  for<'s> extern "C" fn(Local<'s, Name>, *const PropertyCallbackInfo);

impl<F> From<F> for GenericNamedPropertyDescriptorCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Name>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoGenericNamedPropertyDescriptorCallback>(
      property: Local<'s, Name>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, property, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_generic_named_property_descriptor_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _property: Local<'s, Name>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn generic_named_property_descriptor_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGenericNamedPropertyDescriptorCallback>(
    _: F,
  ) -> GenericNamedPropertyDescriptorCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_generic_named_property_descriptor_callback);
}

#[test]
fn generic_named_property_descriptor_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GenericNamedPropertyDescriptorCallback>,
  ) -> GenericNamedPropertyDescriptorCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_trait(mock_generic_named_property_descriptor_callback);
}

#[test]
fn generic_named_property_descriptor_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_generic_named_property_descriptor_callback!(),
  ) -> GenericNamedPropertyDescriptorCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_macro(mock_generic_named_property_descriptor_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _property, _arguments, _return_value| unimplemented!(),
  );
}

/// See `v8::GenericNamedPropertyGetterCallback`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn indexed_property_getter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   index: u32,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct IndexedPropertyGetterCallback(RawIndexedPropertyGetterCallback);

pub trait IntoIndexedPropertyGetterCallback:
  UnitType
  + Into<IndexedPropertyGetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    u32,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoIndexedPropertyGetterCallback for F where
  F: UnitType
    + Into<IndexedPropertyGetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_indexed_property_getter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::IndexedPropertyGetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      u32,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawIndexedPropertyGetterCallback =
  extern "C" fn(u32, *const PropertyCallbackInfo);

impl<F> From<F> for IndexedPropertyGetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoIndexedPropertyGetterCallback>(
      index: u32,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, index, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_indexed_property_getter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _index: u32,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn indexed_property_getter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoIndexedPropertyGetterCallback>(
    _: F,
  ) -> IndexedPropertyGetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_indexed_property_getter_callback);
}

#[test]
fn indexed_property_getter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<IndexedPropertyGetterCallback>,
  ) -> IndexedPropertyGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_indexed_property_getter_callback);
}

#[test]
fn indexed_property_getter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_indexed_property_getter_callback!(),
  ) -> IndexedPropertyGetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_indexed_property_getter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _index, _arguments, _return_value| unimplemented!(),
  );
}

/// See `v8::GenericNamedPropertySetterCallback`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn indexed_property_setter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   index: u32,
///   value: v8::Local<'s, v8::Value>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct IndexedPropertySetterCallback(RawIndexedPropertySetterCallback);

pub trait IntoIndexedPropertySetterCallback:
  UnitType
  + Into<IndexedPropertySetterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    u32,
    Local<'s, Value>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoIndexedPropertySetterCallback for F where
  F: UnitType
    + Into<IndexedPropertySetterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_indexed_property_setter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::IndexedPropertySetterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      u32,
      $crate::Local<'__s, $crate::Value>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawIndexedPropertySetterCallback =
  for<'s> extern "C" fn(u32, Local<'s, Value>, *const PropertyCallbackInfo);

impl<F> From<F> for IndexedPropertySetterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      Local<'s, Value>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoIndexedPropertySetterCallback>(
      index: u32,
      value: Local<'s, Value>,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, index, value, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_indexed_property_setter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _index: u32,
  _value: Local<'s, Value>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn indexed_property_setter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoIndexedPropertySetterCallback>(
    _: F,
  ) -> IndexedPropertySetterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_indexed_property_setter_callback);
}

#[test]
fn indexed_property_setter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<IndexedPropertySetterCallback>,
  ) -> IndexedPropertySetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_indexed_property_setter_callback);
}

#[test]
fn indexed_property_setter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_indexed_property_setter_callback!(),
  ) -> IndexedPropertySetterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_indexed_property_setter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _index, _value, _arguments, _return_value| unimplemented!(),
  );
}

/// See `v8::GenericNamedPropertyQueryCallback`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn indexed_property_query_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   index: u32,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Integer>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct IndexedPropertyQueryCallback(RawIndexedPropertyQueryCallback);

pub trait IntoIndexedPropertyQueryCallback:
  UnitType
  + Into<IndexedPropertyQueryCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    u32,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Integer>,
  )
{
}

impl<F> IntoIndexedPropertyQueryCallback for F where
  F: UnitType
    + Into<IndexedPropertyQueryCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Integer>,
    )
{
}

#[macro_export]
macro_rules! impl_into_indexed_property_query_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::IndexedPropertyQueryCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      u32,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Integer>,
    )
  };
}

type RawIndexedPropertyQueryCallback =
  extern "C" fn(u32, *const PropertyCallbackInfo);

impl<F> From<F> for IndexedPropertyQueryCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Integer>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoIndexedPropertyQueryCallback>(
      index: u32,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Integer>::from_property_callback_info(info);
      (F::get())(scope, index, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_indexed_property_query_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _index: u32,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Integer>,
) {
  unimplemented!()
}

#[test]
fn indexed_property_query_callback_as_type_param() {
  fn pass_as_type_param<F: IntoIndexedPropertyQueryCallback>(
    _: F,
  ) -> IndexedPropertyQueryCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_indexed_property_query_callback);
}

#[test]
fn indexed_property_query_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<IndexedPropertyQueryCallback>,
  ) -> IndexedPropertyQueryCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_indexed_property_query_callback);
}

#[test]
fn indexed_property_query_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_indexed_property_query_callback!(),
  ) -> IndexedPropertyQueryCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_indexed_property_query_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _index, _arguments, _return_value| unimplemented!(),
  );
}

/// See `v8::GenericNamedPropertyDeleterCallback`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn indexed_property_deleter_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   index: u32,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Boolean>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct IndexedPropertyDeleterCallback(RawIndexedPropertyDeleterCallback);

pub trait IntoIndexedPropertyDeleterCallback:
  UnitType
  + Into<IndexedPropertyDeleterCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    u32,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Boolean>,
  )
{
}

impl<F> IntoIndexedPropertyDeleterCallback for F where
  F: UnitType
    + Into<IndexedPropertyDeleterCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Boolean>,
    )
{
}

#[macro_export]
macro_rules! impl_into_indexed_property_deleter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::IndexedPropertyDeleterCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      u32,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Boolean>,
    )
  };
}

type RawIndexedPropertyDeleterCallback =
  extern "C" fn(u32, *const PropertyCallbackInfo);

impl<F> From<F> for IndexedPropertyDeleterCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Boolean>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoIndexedPropertyDeleterCallback>(
      index: u32,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Boolean>::from_property_callback_info(info);
      (F::get())(scope, index, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_indexed_property_deleter_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _index: u32,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Boolean>,
) {
  unimplemented!()
}

#[test]
fn indexed_property_deleter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoIndexedPropertyDeleterCallback>(
    _: F,
  ) -> IndexedPropertyDeleterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_indexed_property_deleter_callback);
}

#[test]
fn indexed_property_deleter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<IndexedPropertyDeleterCallback>,
  ) -> IndexedPropertyDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_indexed_property_deleter_callback);
}

#[test]
fn indexed_property_deleter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_indexed_property_deleter_callback!(),
  ) -> IndexedPropertyDeleterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_indexed_property_deleter_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _index, _arguments, _return_value| unimplemented!(),
  );
}

/// Returns an array containing the indices of the properties the indexed
/// property getter intercepts.
///
/// Note: The values in the array must be uint32_t.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn indexed_property_enumerator_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Array>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct IndexedPropertyEnumeratorCallback(
  RawIndexedPropertyEnumeratorCallback,
);

pub trait IntoIndexedPropertyEnumeratorCallback:
  UnitType
  + Into<IndexedPropertyEnumeratorCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Array>,
  )
{
}

impl<F> IntoIndexedPropertyEnumeratorCallback for F where
  F: UnitType
    + Into<IndexedPropertyEnumeratorCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Array>,
    )
{
}

#[macro_export]
macro_rules! impl_into_indexed_property_enumerator_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::IndexedPropertyEnumeratorCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Array>,
    )
  };
}

type RawIndexedPropertyEnumeratorCallback =
  extern "C" fn(*const PropertyCallbackInfo);

impl<F> From<F> for IndexedPropertyEnumeratorCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Array>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoIndexedPropertyEnumeratorCallback>(
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Array>::from_property_callback_info(info);
      (F::get())(scope, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_indexed_property_enumerator_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Array>,
) {
  unimplemented!()
}

#[test]
fn indexed_property_enumerator_callback_as_type_param() {
  fn pass_as_type_param<F: IntoIndexedPropertyEnumeratorCallback>(
    _: F,
  ) -> IndexedPropertyEnumeratorCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_indexed_property_enumerator_callback);
}

#[test]
fn indexed_property_enumerator_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<IndexedPropertyEnumeratorCallback>,
  ) -> IndexedPropertyEnumeratorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_indexed_property_enumerator_callback);
}

#[test]
fn indexed_property_enumerator_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_indexed_property_enumerator_callback!(),
  ) -> IndexedPropertyEnumeratorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_indexed_property_enumerator_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _arguments, _return_value| unimplemented!(),
  );
}

/// See `v8::GenericNamedPropertyDefinerCallback`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn indexed_property_definer_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   index: u32,
///   desc: &v8::PropertyDescriptor,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct IndexedPropertyDefinerCallback(RawIndexedPropertyDefinerCallback);

pub trait IntoIndexedPropertyDefinerCallback:
  UnitType
  + Into<IndexedPropertyDefinerCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    u32,
    &PropertyDescriptor,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoIndexedPropertyDefinerCallback for F where
  F: UnitType
    + Into<IndexedPropertyDefinerCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      &PropertyDescriptor,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_indexed_property_definer_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::IndexedPropertyDefinerCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      u32,
      &$crate::PropertyDescriptor,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawIndexedPropertyDefinerCallback =
  extern "C" fn(u32, *const PropertyDescriptor, *const PropertyCallbackInfo);

impl<F> From<F> for IndexedPropertyDefinerCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      &PropertyDescriptor,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoIndexedPropertyDefinerCallback>(
      index: u32,
      desc: *const PropertyDescriptor,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let desc = unsafe { &*desc };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, index, desc, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_indexed_property_definer_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _index: u32,
  _desc: &PropertyDescriptor,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn indexed_property_definer_callback_as_type_param() {
  fn pass_as_type_param<F: IntoIndexedPropertyDefinerCallback>(
    _: F,
  ) -> IndexedPropertyDefinerCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_indexed_property_definer_callback);
}

#[test]
fn indexed_property_definer_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<IndexedPropertyDefinerCallback>,
  ) -> IndexedPropertyDefinerCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_indexed_property_definer_callback);
}

#[test]
fn indexed_property_definer_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_indexed_property_definer_callback!(),
  ) -> IndexedPropertyDefinerCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_indexed_property_definer_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _index, _desc, _arguments, _return_value| unimplemented!(),
  );
}

/// See `v8::GenericNamedPropertyDescriptorCallback`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn indexed_property_descriptor_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   index: u32,
///   arguments: v8::PropertyCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct IndexedPropertyDescriptorCallback(
  RawIndexedPropertyDescriptorCallback,
);

pub trait IntoIndexedPropertyDescriptorCallback:
  UnitType
  + Into<IndexedPropertyDescriptorCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    u32,
    PropertyCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoIndexedPropertyDescriptorCallback for F where
  F: UnitType
    + Into<IndexedPropertyDescriptorCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_indexed_property_descriptor_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::IndexedPropertyDescriptorCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      u32,
      $crate::PropertyCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawIndexedPropertyDescriptorCallback =
  extern "C" fn(u32, *const PropertyCallbackInfo);

impl<F> From<F> for IndexedPropertyDescriptorCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      u32,
      PropertyCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoIndexedPropertyDescriptorCallback>(
      index: u32,
      info: *const PropertyCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        PropertyCallbackArguments::from_property_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_property_callback_info(info);
      (F::get())(scope, index, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_indexed_property_descriptor_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _index: u32,
  _arguments: PropertyCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn indexed_property_descriptor_callback_as_type_param() {
  fn pass_as_type_param<F: IntoIndexedPropertyDescriptorCallback>(
    _: F,
  ) -> IndexedPropertyDescriptorCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_indexed_property_descriptor_callback);
}

#[test]
fn indexed_property_descriptor_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<IndexedPropertyDescriptorCallback>,
  ) -> IndexedPropertyDescriptorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_indexed_property_descriptor_callback);
}

#[test]
fn indexed_property_descriptor_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_indexed_property_descriptor_callback!(),
  ) -> IndexedPropertyDescriptorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_indexed_property_descriptor_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _index, _arguments, _return_value| unimplemented!(),
  );
}

/// Returns true if the given context should be allowed to access the given
/// object.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn access_check_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   accessed_object: v8::Local<'s, v8::Object>,
///   data: v8::Local<'s, v8::Value>,
/// ) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AccessCheckCallback(RawAccessCheckCallback);

pub trait IntoAccessCheckCallback:
  UnitType
  + Into<AccessCheckCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Object>,
    Local<'s, Value>,
  ) -> bool
{
}

impl<F> IntoAccessCheckCallback for F where
  F: UnitType
    + Into<AccessCheckCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      Local<'s, Value>,
    ) -> bool
{
}

#[macro_export]
macro_rules! impl_into_access_check_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AccessCheckCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Object>,
      $crate::Local<'__s, $crate::Value>,
    ) -> bool
  };
}

type RawAccessCheckCallback = for<'s> extern "C" fn(
  Local<'s, Context>,
  Local<'s, Object>,
  Local<'s, Value>,
) -> bool;

impl<F> From<F> for AccessCheckCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      Local<'s, Value>,
    ) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAccessCheckCallback>(
      accessing_context: Local<'s, Context>,
      accessed_object: Local<'s, Object>,
      data: Local<'s, Value>,
    ) -> bool {
      let scope = &mut unsafe { CallbackScope::new(accessing_context) };
      (F::get())(scope, accessed_object, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_access_check_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _accessed_object: Local<'s, Object>,
  _data: Local<'s, Value>,
) -> bool {
  unimplemented!()
}

#[test]
fn access_check_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAccessCheckCallback>(
    _: F,
  ) -> AccessCheckCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_access_check_callback);
}

#[test]
fn access_check_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AccessCheckCallback>,
  ) -> AccessCheckCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_access_check_callback);
}

#[test]
fn access_check_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_access_check_callback!(),
  ) -> AccessCheckCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_access_check_callback);
  let _ =
    pass_as_impl_into_macro(|_scope, _accessed_object, _data| unimplemented!());
}

// === FatalErrorCallback ===

/// ## Example
///
/// ```
/// # use std::ffi::CStr;
/// #
/// fn fatal_error_callback_example(location: &CStr, message: &CStr) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct FatalErrorCallback(RawFatalErrorCallback);

pub trait IntoFatalErrorCallback:
  UnitType + Into<FatalErrorCallback> + FnOnce(&CStr, &CStr)
{
}

impl<F> IntoFatalErrorCallback for F where
  F: UnitType + Into<FatalErrorCallback> + FnOnce(&CStr, &CStr)
{
}

#[macro_export]
macro_rules! impl_into_fatal_error_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::FatalErrorCallback>
    + ::std::ops::FnOnce(
      &::std::ffi::CStr,
      &::std::ffi::CStr,
    )
  };
}

type RawFatalErrorCallback = extern "C" fn(*const c_char, *const c_char);

impl<F> From<F> for FatalErrorCallback
where
  F: UnitType + FnOnce(&CStr, &CStr),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoFatalErrorCallback>(
      location: *const c_char,
      message: *const c_char,
    ) {
      let location = unsafe { CStr::from_ptr(location) };
      let message = unsafe { CStr::from_ptr(message) };
      (F::get())(location, message)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_fatal_error_callback(_location: &CStr, _message: &CStr) {
  unimplemented!()
}

#[test]
fn fatal_error_callback_as_type_param() {
  fn pass_as_type_param<F: IntoFatalErrorCallback>(_: F) -> FatalErrorCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_fatal_error_callback);
}

#[test]
fn fatal_error_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<FatalErrorCallback>,
  ) -> FatalErrorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_fatal_error_callback);
}

#[test]
fn fatal_error_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_fatal_error_callback!(),
  ) -> FatalErrorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_fatal_error_callback);
  let _ = pass_as_impl_into_macro(|_location, _message| unimplemented!());
}

// === OOMErrorCallback ===

/// ## Example
///
/// ```
/// # use std::ffi::CStr;
/// #
/// fn oom_error_callback_example(location: &CStr, is_heap_oom: bool) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct OOMErrorCallback(RawOOMErrorCallback);

pub trait IntoOOMErrorCallback:
  UnitType + Into<OOMErrorCallback> + FnOnce(&CStr, bool)
{
}

impl<F> IntoOOMErrorCallback for F where
  F: UnitType + Into<OOMErrorCallback> + FnOnce(&CStr, bool)
{
}

#[macro_export]
macro_rules! impl_into_oom_error_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::OOMErrorCallback>
    + ::std::ops::FnOnce(
      &::std::ffi::CStr,
      bool,
    )
  };
}

type RawOOMErrorCallback = extern "C" fn(*const c_char, bool);

impl<F> From<F> for OOMErrorCallback
where
  F: UnitType + FnOnce(&CStr, bool),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoOOMErrorCallback>(
      location: *const c_char,
      is_heap_oom: bool,
    ) {
      let location = unsafe { CStr::from_ptr(location) };
      (F::get())(location, is_heap_oom)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_oom_error_callback(_location: &CStr, _is_heap_oom: bool) {
  unimplemented!()
}

#[test]
fn oom_error_callback_as_type_param() {
  fn pass_as_type_param<F: IntoOOMErrorCallback>(_: F) -> OOMErrorCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_oom_error_callback);
}

#[test]
fn oom_error_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<OOMErrorCallback>,
  ) -> OOMErrorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_oom_error_callback);
}

#[test]
fn oom_error_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_oom_error_callback!(),
  ) -> OOMErrorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_oom_error_callback);
  let _ = pass_as_impl_into_macro(|_location, _is_heap_oom| unimplemented!());
}

// === DcheckErrorCallback ===

/// ## Example
///
/// ```
/// # use std::ffi::CStr;
/// #
/// fn dcheck_error_callback_example(file: &CStr, line: i32, message: &CStr) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct DcheckErrorCallback(RawDcheckErrorCallback);

pub trait IntoDcheckErrorCallback:
  UnitType + Into<DcheckErrorCallback> + FnOnce(&CStr, i32, &CStr)
{
}

impl<F> IntoDcheckErrorCallback for F where
  F: UnitType + Into<DcheckErrorCallback> + FnOnce(&CStr, i32, &CStr)
{
}

#[macro_export]
macro_rules! impl_into_dcheck_error_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::DcheckErrorCallback>
    + ::std::ops::FnOnce(
      &::std::ffi::CStr,
      i32,
      &::std::ffi::CStr,
    )
  };
}

type RawDcheckErrorCallback =
  extern "C" fn(*const c_char, c_int, *const c_char);

impl<F> From<F> for DcheckErrorCallback
where
  F: UnitType + FnOnce(&CStr, i32, &CStr),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoDcheckErrorCallback>(
      file: *const c_char,
      line: c_int,
      message: *const c_char,
    ) {
      let file = unsafe { CStr::from_ptr(file) };
      let message = unsafe { CStr::from_ptr(message) };
      (F::get())(file, line, message)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_dcheck_error_callback(_file: &CStr, _line: i32, _message: &CStr) {
  unimplemented!()
}

#[test]
fn dcheck_error_callback_as_type_param() {
  fn pass_as_type_param<F: IntoDcheckErrorCallback>(
    _: F,
  ) -> DcheckErrorCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_dcheck_error_callback);
}

#[test]
fn dcheck_error_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<DcheckErrorCallback>,
  ) -> DcheckErrorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_dcheck_error_callback);
}

#[test]
fn dcheck_error_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_dcheck_error_callback!(),
  ) -> DcheckErrorCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_dcheck_error_callback);
  let _ = pass_as_impl_into_macro(|_file, _line, _message| unimplemented!());
}

// === MessageCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn message_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   message: v8::Local<'s, v8::Message>,
///   data: v8::Local<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct MessageCallback(RawMessageCallback);

pub trait IntoMessageCallback:
  UnitType
  + Into<MessageCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, Message>, Local<'s, Value>)
{
}

impl<F> IntoMessageCallback for F where
  F: UnitType
    + Into<MessageCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, Message>, Local<'s, Value>)
{
}

#[macro_export]
macro_rules! impl_into_message_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::MessageCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Message>,
      $crate::Local<'__s, $crate::Value>,
    )
  };
}

type RawMessageCallback =
  for<'s> extern "C" fn(Local<'s, Message>, Local<'s, Value>);

impl<F> From<F> for MessageCallback
where
  F: UnitType
    + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, Message>, Local<'s, Value>),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoMessageCallback>(
      message: Local<'s, Message>,
      data: Local<'s, Value>,
    ) {
      let scope = &mut unsafe { CallbackScope::new(message) };
      (F::get())(scope, message, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_message_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _message: Local<'s, Message>,
  _data: Local<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn message_callback_as_type_param() {
  fn pass_as_type_param<F: IntoMessageCallback>(_: F) -> MessageCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_message_callback);
}

#[test]
fn message_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(f: impl Into<MessageCallback>) -> MessageCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_message_callback);
}

#[test]
fn message_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_message_callback!(),
  ) -> MessageCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_message_callback);
  let _ = pass_as_impl_into_macro(|_scope, _message, _data| unimplemented!());
}

// === LogEventCallback ===

/// ## Example
///
/// ```
/// # use std::ffi::CStr;
/// #
/// fn log_event_callback_example(name: &CStr, event: i32) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct LogEventCallback(RawLogEventCallback);

pub trait IntoLogEventCallback:
  UnitType + Into<LogEventCallback> + FnOnce(&CStr, i32)
{
}

impl<F> IntoLogEventCallback for F where
  F: UnitType + Into<LogEventCallback> + FnOnce(&CStr, i32)
{
}

#[macro_export]
macro_rules! impl_into_log_event_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::LogEventCallback>
    + ::std::ops::FnOnce(
      &::std::ffi::CStr,
      i32,
    )
  };
}

type RawLogEventCallback = extern "C" fn(*const c_char, c_int);

impl<F> From<F> for LogEventCallback
where
  F: UnitType + FnOnce(&CStr, i32),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoLogEventCallback>(
      name: *const c_char,
      event: c_int,
    ) {
      let name = unsafe { CStr::from_ptr(name) };
      (F::get())(name, event)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_log_event_callback(_name: &CStr, _event: i32) {
  unimplemented!()
}

#[test]
fn log_event_callback_as_type_param() {
  fn pass_as_type_param<F: IntoLogEventCallback>(_: F) -> LogEventCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_log_event_callback);
}

#[test]
fn log_event_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<LogEventCallback>,
  ) -> LogEventCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_log_event_callback);
}

#[test]
fn log_event_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_log_event_callback!(),
  ) -> LogEventCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_log_event_callback);
  let _ = pass_as_impl_into_macro(|_name, _event| unimplemented!());
}

// === CounterLookupCallback ===

/// ## Example
///
/// ```
/// # use std::cell::Cell;
/// # use std::ffi::CStr;
/// #
/// fn counter_lookup_callback_example(name: &CStr) -> &Cell<i32> {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct CounterLookupCallback(RawCounterLookupCallback);

pub trait IntoCounterLookupCallback:
  UnitType + Into<CounterLookupCallback> + FnOnce(&CStr) -> &Cell<i32>
{
}

impl<F> IntoCounterLookupCallback for F where
  F: UnitType + Into<CounterLookupCallback> + FnOnce(&CStr) -> &Cell<i32>
{
}

#[macro_export]
macro_rules! impl_into_counter_lookup_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::CounterLookupCallback>
    + ::std::ops::FnOnce(
      &::std::ffi::CStr,
    ) -> &::std::cell::Cell<i32>
  };
}

type RawCounterLookupCallback = extern "C" fn(*const c_char) -> *mut c_int;

impl<F> From<F> for CounterLookupCallback
where
  F: UnitType + FnOnce(&CStr) -> &Cell<i32>,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoCounterLookupCallback>(
      name: *const c_char,
    ) -> *mut c_int {
      let name = unsafe { CStr::from_ptr(name) };
      (F::get())(name).as_ptr()
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_counter_lookup_callback(_name: &CStr) -> &Cell<i32> {
  unimplemented!()
}

#[test]
fn counter_lookup_callback_as_type_param() {
  fn pass_as_type_param<F: IntoCounterLookupCallback>(
    _: F,
  ) -> CounterLookupCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_counter_lookup_callback);
}

#[test]
fn counter_lookup_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<CounterLookupCallback>,
  ) -> CounterLookupCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_counter_lookup_callback);
}

#[test]
fn counter_lookup_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_counter_lookup_callback!(),
  ) -> CounterLookupCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_counter_lookup_callback);
  let _ = pass_as_impl_into_macro(|_name| unimplemented!());
}

// === CreateHistogramCallback ===

/// ## Example
///
/// ```
/// # use std::ffi::CStr;
/// #
/// fn create_histogram_callback_example(
///   name: &CStr,
///   min: i32,
///   max: i32,
///   buckets: usize,
/// ) -> *mut () {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct CreateHistogramCallback(RawCreateHistogramCallback);

pub trait IntoCreateHistogramCallback:
  UnitType
  + Into<CreateHistogramCallback>
  + FnOnce(&CStr, i32, i32, usize) -> *mut ()
{
}

impl<F> IntoCreateHistogramCallback for F where
  F: UnitType
    + Into<CreateHistogramCallback>
    + FnOnce(&CStr, i32, i32, usize) -> *mut ()
{
}

#[macro_export]
macro_rules! impl_into_create_histogram_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::CreateHistogramCallback>
    + ::std::ops::FnOnce(
      &::std::ffi::CStr,
      i32,
      i32,
      usize,
    ) -> *mut ()
  };
}

type RawCreateHistogramCallback =
  extern "C" fn(*const c_char, c_int, c_int, usize) -> *mut c_void;

impl<F> From<F> for CreateHistogramCallback
where
  F: UnitType + FnOnce(&CStr, i32, i32, usize) -> *mut (),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoCreateHistogramCallback>(
      name: *const c_char,
      min: c_int,
      max: c_int,
      buckets: usize,
    ) -> *mut c_void {
      let name = unsafe { CStr::from_ptr(name) };
      (F::get())(name, min, max, buckets) as *mut c_void
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_create_histogram_callback(
  _name: &CStr,
  _min: i32,
  _max: i32,
  _buckets: usize,
) -> *mut () {
  unimplemented!()
}

#[test]
fn create_histogram_callback_as_type_param() {
  fn pass_as_type_param<F: IntoCreateHistogramCallback>(
    _: F,
  ) -> CreateHistogramCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_create_histogram_callback);
}

#[test]
fn create_histogram_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<CreateHistogramCallback>,
  ) -> CreateHistogramCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_create_histogram_callback);
}

#[test]
fn create_histogram_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_create_histogram_callback!(),
  ) -> CreateHistogramCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_create_histogram_callback);
  let _ =
    pass_as_impl_into_macro(|_name, _min, _max, _buckets| unimplemented!());
}

// === AddHistogramSampleCallback ===

/// ## Example
///
/// ```
/// fn add_histogram_sample_callback_example(histogram: *mut (), sample: i32) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AddHistogramSampleCallback(RawAddHistogramSampleCallback);

pub trait IntoAddHistogramSampleCallback:
  UnitType + Into<AddHistogramSampleCallback> + FnOnce(*mut (), i32)
{
}

impl<F> IntoAddHistogramSampleCallback for F where
  F: UnitType + Into<AddHistogramSampleCallback> + FnOnce(*mut (), i32)
{
}

#[macro_export]
macro_rules! impl_into_add_histogram_sample_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AddHistogramSampleCallback>
    + ::std::ops::FnOnce(
      *mut (),
      i32,
    )
  };
}

type RawAddHistogramSampleCallback = extern "C" fn(*mut c_void, c_int);

impl<F> From<F> for AddHistogramSampleCallback
where
  F: UnitType + FnOnce(*mut (), i32),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoAddHistogramSampleCallback>(
      histogram: *mut c_void,
      sample: c_int,
    ) {
      let histogram = histogram as *mut ();
      (F::get())(histogram, sample)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_add_histogram_sample_callback(_histogram: *mut (), _sample: i32) {
  unimplemented!()
}

#[test]
fn add_histogram_sample_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAddHistogramSampleCallback>(
    _: F,
  ) -> AddHistogramSampleCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_add_histogram_sample_callback);
}

#[test]
fn add_histogram_sample_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AddHistogramSampleCallback>,
  ) -> AddHistogramSampleCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_add_histogram_sample_callback);
}

#[test]
fn add_histogram_sample_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_add_histogram_sample_callback!(),
  ) -> AddHistogramSampleCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_add_histogram_sample_callback);
  let _ = pass_as_impl_into_macro(|_histogram, _sample| unimplemented!());
}

// === AddCrashKeyCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// # use std::ffi::CStr;
/// #
/// fn add_crash_key_callback_example(id: v8::CrashKeyId, value: &CStr) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AddCrashKeyCallback(RawAddCrashKeyCallback);

pub trait IntoAddCrashKeyCallback:
  UnitType + Into<AddCrashKeyCallback> + FnOnce(CrashKeyId, &CStr)
{
}

impl<F> IntoAddCrashKeyCallback for F where
  F: UnitType + Into<AddCrashKeyCallback> + FnOnce(CrashKeyId, &CStr)
{
}

#[macro_export]
macro_rules! impl_into_add_crash_key_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AddCrashKeyCallback>
    + ::std::ops::FnOnce(
      $crate::CrashKeyId,
      &::std::ffi::CStr,
    )
  };
}

type RawAddCrashKeyCallback = extern "C" fn(CrashKeyId, *const CxxString);

impl<F> From<F> for AddCrashKeyCallback
where
  F: UnitType + FnOnce(CrashKeyId, &CStr),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoAddCrashKeyCallback>(
      id: CrashKeyId,
      value: *const CxxString,
    ) {
      let value = <&CStr>::from(unsafe { &*value });
      (F::get())(id, value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_add_crash_key_callback(_id: CrashKeyId, _value: &CStr) {
  unimplemented!()
}

#[test]
fn add_crash_key_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAddCrashKeyCallback>(
    _: F,
  ) -> AddCrashKeyCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_add_crash_key_callback);
}

#[test]
fn add_crash_key_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AddCrashKeyCallback>,
  ) -> AddCrashKeyCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_add_crash_key_callback);
}

#[test]
fn add_crash_key_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_add_crash_key_callback!(),
  ) -> AddCrashKeyCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_add_crash_key_callback);
  let _ = pass_as_impl_into_macro(|_id, _value| unimplemented!());
}

// === BeforeCallEnteredCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn before_call_entered_callback_example(isolate: &mut v8::Isolate) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct BeforeCallEnteredCallback(RawBeforeCallEnteredCallback);

pub trait IntoBeforeCallEnteredCallback:
  UnitType + Into<BeforeCallEnteredCallback> + FnOnce(&mut Isolate)
{
}

impl<F> IntoBeforeCallEnteredCallback for F where
  F: UnitType + Into<BeforeCallEnteredCallback> + FnOnce(&mut Isolate)
{
}

#[macro_export]
macro_rules! impl_into_before_call_entered_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::BeforeCallEnteredCallback>
    + ::std::ops::FnOnce(
      &mut $crate::Isolate,
    )
  };
}

type RawBeforeCallEnteredCallback = extern "C" fn(*mut Isolate);

impl<F> From<F> for BeforeCallEnteredCallback
where
  F: UnitType + FnOnce(&mut Isolate),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoBeforeCallEnteredCallback>(
      isolate: *mut Isolate,
    ) {
      let isolate = unsafe { &mut *isolate };
      (F::get())(isolate)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_before_call_entered_callback(_isolate: &mut Isolate) {
  unimplemented!()
}

#[test]
fn before_call_entered_callback_as_type_param() {
  fn pass_as_type_param<F: IntoBeforeCallEnteredCallback>(
    _: F,
  ) -> BeforeCallEnteredCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_before_call_entered_callback);
}

#[test]
fn before_call_entered_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<BeforeCallEnteredCallback>,
  ) -> BeforeCallEnteredCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_before_call_entered_callback);
}

#[test]
fn before_call_entered_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_before_call_entered_callback!(),
  ) -> BeforeCallEnteredCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_before_call_entered_callback);
  let _ = pass_as_impl_into_macro(|_isolate| unimplemented!());
}

// === CallCompletedCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn call_completed_callback_example(isolate: &mut v8::Isolate) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct CallCompletedCallback(RawCallCompletedCallback);

pub trait IntoCallCompletedCallback:
  UnitType + Into<CallCompletedCallback> + FnOnce(&mut Isolate)
{
}

impl<F> IntoCallCompletedCallback for F where
  F: UnitType + Into<CallCompletedCallback> + FnOnce(&mut Isolate)
{
}

#[macro_export]
macro_rules! impl_into_call_completed_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::CallCompletedCallback>
    + ::std::ops::FnOnce(
      &mut $crate::Isolate,
    )
  };
}

type RawCallCompletedCallback = extern "C" fn(*mut Isolate);

impl<F> From<F> for CallCompletedCallback
where
  F: UnitType + FnOnce(&mut Isolate),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoCallCompletedCallback>(isolate: *mut Isolate) {
      let isolate = unsafe { &mut *isolate };
      (F::get())(isolate)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_call_completed_callback(_isolate: &mut Isolate) {
  unimplemented!()
}

#[test]
fn call_completed_callback_as_type_param() {
  fn pass_as_type_param<F: IntoCallCompletedCallback>(
    _: F,
  ) -> CallCompletedCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_call_completed_callback);
}

#[test]
fn call_completed_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<CallCompletedCallback>,
  ) -> CallCompletedCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_call_completed_callback);
}

#[test]
fn call_completed_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_call_completed_callback!(),
  ) -> CallCompletedCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_call_completed_callback);
  let _ = pass_as_impl_into_macro(|_isolate| unimplemented!());
}

/// HostImportModuleDynamicallyCallback is called when we require the
/// embedder to load a module. This is used as part of the dynamic
/// import syntax.
///
/// The referrer contains metadata about the script/module that calls
/// import.
///
/// The specifier is the name of the module that should be imported.
///
/// The embedder must compile, instantiate, evaluate the Module, and
/// obtain it's namespace object.
///
/// The Promise returned from this function is forwarded to userland
/// JavaScript. The embedder must resolve this promise with the module
/// namespace object. In case of an exception, the embedder must reject
/// this promise with the exception. If the promise creation itself
/// fails (e.g. due to stack overflow), the embedder must propagate
/// that exception by returning an empty MaybeLocal.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn host_import_module_dynamically_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   referrer: v8::Local<'s, v8::ScriptOrModule>,
///   specifier: v8::Local<'s, v8::String>,
/// ) -> Option<v8::Local<'s, v8::Promise>> {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct HostImportModuleDynamicallyCallback(
  RawHostImportModuleDynamicallyCallback,
);

pub trait IntoHostImportModuleDynamicallyCallback:
  UnitType
  + Into<HostImportModuleDynamicallyCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, ScriptOrModule>,
    Local<'s, String>,
  ) -> Option<Local<'s, Promise>>
{
}

impl<F> IntoHostImportModuleDynamicallyCallback for F where
  F: UnitType
    + Into<HostImportModuleDynamicallyCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, ScriptOrModule>,
      Local<'s, String>,
    ) -> Option<Local<'s, Promise>>
{
}

#[macro_export]
macro_rules! impl_into_host_import_module_dynamically_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::HostImportModuleDynamicallyCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::ScriptOrModule>,
      $crate::Local<'__s, $crate::String>,
    ) -> ::std::option::Option<$crate::Local<'__s, $crate::Promise>>
  };
}

#[cfg(target_family = "unix")]
type RawHostImportModuleDynamicallyCallback =
  for<'s> extern "C" fn(
    Local<'s, Context>,
    Local<'s, ScriptOrModule>,
    Local<'s, String>,
  ) -> Option<Local<'s, Promise>>;

#[cfg(all(target_family = "windows", target_arch = "x86_64"))]
type RawHostImportModuleDynamicallyCallback =
  for<'s> extern "C" fn(
    *mut Option<Local<'s, Promise>>,
    Local<'s, Context>,
    Local<'s, ScriptOrModule>,
    Local<'s, String>,
  ) -> *mut Option<Local<'s, Promise>>;

impl<F> From<F> for HostImportModuleDynamicallyCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, ScriptOrModule>,
      Local<'s, String>,
    ) -> Option<Local<'s, Promise>>,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    fn signature_adapter<'s, F: IntoHostImportModuleDynamicallyCallback>(
      context: Local<'s, Context>,
      referrer: Local<'s, ScriptOrModule>,
      specifier: Local<'s, String>,
    ) -> Option<Local<'s, Promise>> {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, referrer, specifier)
    }

    #[cfg(target_family = "unix")]
    #[inline(always)]
    extern "C" fn abi_adapter<
      's,
      F: IntoHostImportModuleDynamicallyCallback,
    >(
      context: Local<'s, Context>,
      referrer: Local<'s, ScriptOrModule>,
      specifier: Local<'s, String>,
    ) -> Option<Local<'s, Promise>> {
      signature_adapter::<F>(context, referrer, specifier)
    }

    #[cfg(all(target_family = "windows", target_arch = "x86_64"))]
    #[inline(always)]
    extern "C" fn abi_adapter<
      's,
      F: IntoHostImportModuleDynamicallyCallback,
    >(
      return_value: *mut Option<Local<'s, Promise>>,
      context: Local<'s, Context>,
      referrer: Local<'s, ScriptOrModule>,
      specifier: Local<'s, String>,
    ) -> *mut Option<Local<'s, Promise>> {
      unsafe {
        std::ptr::write(
          return_value,
          signature_adapter::<F>(context, referrer, specifier),
        );
        return_value
      }
    }

    Self(abi_adapter::<F>)
  }
}

#[cfg(test)]
fn mock_host_import_module_dynamically_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _referrer: Local<'s, ScriptOrModule>,
  _specifier: Local<'s, String>,
) -> Option<Local<'s, Promise>> {
  unimplemented!()
}

#[test]
fn host_import_module_dynamically_callback_as_type_param() {
  fn pass_as_type_param<F: IntoHostImportModuleDynamicallyCallback>(
    _: F,
  ) -> HostImportModuleDynamicallyCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_host_import_module_dynamically_callback);
}

#[test]
fn host_import_module_dynamically_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<HostImportModuleDynamicallyCallback>,
  ) -> HostImportModuleDynamicallyCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_host_import_module_dynamically_callback);
}

#[test]
fn host_import_module_dynamically_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_host_import_module_dynamically_callback!(),
  ) -> HostImportModuleDynamicallyCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_host_import_module_dynamically_callback);
  let _ =
    pass_as_impl_into_macro(|_scope, _referrer, _specifier| unimplemented!());
}

/// HostInitializeImportMetaObjectCallback is called the first time import.meta
/// is accessed for a module. Subsequent access will reuse the same value. The
/// callback must not throw.
///
/// The method combines two implementation-defined abstract operations into one:
/// HostGetImportMetaProperties and HostFinalizeImportMeta.
///
/// The embedder should use v8::Object::CreateDataProperty to add properties on
/// the meta object.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn host_initialize_import_meta_object_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   module: v8::Local<'s, v8::Module>,
///   meta: v8::Local<'s, v8::Object>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct HostInitializeImportMetaObjectCallback(
  RawHostInitializeImportMetaObjectCallback,
);

pub trait IntoHostInitializeImportMetaObjectCallback:
  UnitType
  + Into<HostInitializeImportMetaObjectCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, Module>, Local<'s, Object>)
{
}

impl<F> IntoHostInitializeImportMetaObjectCallback for F where
  F: UnitType
    + Into<HostInitializeImportMetaObjectCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, Module>, Local<'s, Object>)
{
}

#[macro_export]
macro_rules! impl_into_host_initialize_import_meta_object_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::HostInitializeImportMetaObjectCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Module>,
      $crate::Local<'__s, $crate::Object>,
    )
  };
}

type RawHostInitializeImportMetaObjectCallback = for<'s> extern "C" fn(
  Local<'s, Context>,
  Local<'s, Module>,
  Local<'s, Object>,
);

impl<F> From<F> for HostInitializeImportMetaObjectCallback
where
  F: UnitType
    + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, Module>, Local<'s, Object>),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoHostInitializeImportMetaObjectCallback>(
      context: Local<'s, Context>,
      module: Local<'s, Module>,
      meta: Local<'s, Object>,
    ) {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, module, meta)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_host_initialize_import_meta_object_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _module: Local<'s, Module>,
  _meta: Local<'s, Object>,
) {
  unimplemented!()
}

#[test]
fn host_initialize_import_meta_object_callback_as_type_param() {
  fn pass_as_type_param<F: IntoHostInitializeImportMetaObjectCallback>(
    _: F,
  ) -> HostInitializeImportMetaObjectCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_host_initialize_import_meta_object_callback);
}

#[test]
fn host_initialize_import_meta_object_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<HostInitializeImportMetaObjectCallback>,
  ) -> HostInitializeImportMetaObjectCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_trait(mock_host_initialize_import_meta_object_callback);
}

#[test]
fn host_initialize_import_meta_object_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_host_initialize_import_meta_object_callback!(),
  ) -> HostInitializeImportMetaObjectCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_macro(mock_host_initialize_import_meta_object_callback);
  let _ = pass_as_impl_into_macro(|_scope, _module, _meta| unimplemented!());
}

/// PrepareStackTraceCallback is called when the stack property of an error is
/// first accessed. The return value will be used as the stack value. If this
/// callback is registed, the `Error.prepareStackTrace` API will be disabled.
/// `sites` is an array of call sites, specified in
/// https://v8.dev/docs/stack-trace-api
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn prepare_stack_trace_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   error: v8::Local<'s, v8::Value>,
///   sites: v8::Local<'s, v8::Array>,
/// ) -> Option<v8::Local<'s, v8::Value>> {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct PrepareStackTraceCallback(RawPrepareStackTraceCallback);

pub trait IntoPrepareStackTraceCallback:
  UnitType
  + Into<PrepareStackTraceCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Value>,
    Local<'s, Array>,
  ) -> Option<Local<'s, Value>>
{
}

impl<F> IntoPrepareStackTraceCallback for F where
  F: UnitType
    + Into<PrepareStackTraceCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Value>,
      Local<'s, Array>,
    ) -> Option<Local<'s, Value>>
{
}

#[macro_export]
macro_rules! impl_into_prepare_stack_trace_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::PrepareStackTraceCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Value>,
      $crate::Local<'__s, $crate::Array>,
    ) -> ::std::option::Option<$crate::Local<'__s, $crate::Value>>
  };
}

#[cfg(target_family = "unix")]
type RawPrepareStackTraceCallback =
  for<'s> extern "C" fn(
    Local<'s, Context>,
    Local<'s, Value>,
    Local<'s, Array>,
  ) -> Option<Local<'s, Value>>;

#[cfg(all(target_family = "windows", target_arch = "x86_64"))]
type RawPrepareStackTraceCallback =
  for<'s> extern "C" fn(
    *mut Option<Local<'s, Value>>,
    Local<'s, Context>,
    Local<'s, Value>,
    Local<'s, Array>,
  ) -> *mut Option<Local<'s, Value>>;

impl<F> From<F> for PrepareStackTraceCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Value>,
      Local<'s, Array>,
    ) -> Option<Local<'s, Value>>,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    fn signature_adapter<'s, F: IntoPrepareStackTraceCallback>(
      context: Local<'s, Context>,
      error: Local<'s, Value>,
      sites: Local<'s, Array>,
    ) -> Option<Local<'s, Value>> {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, error, sites)
    }

    #[cfg(target_family = "unix")]
    #[inline(always)]
    extern "C" fn abi_adapter<'s, F: IntoPrepareStackTraceCallback>(
      context: Local<'s, Context>,
      error: Local<'s, Value>,
      sites: Local<'s, Array>,
    ) -> Option<Local<'s, Value>> {
      signature_adapter::<F>(context, error, sites)
    }

    #[cfg(all(target_family = "windows", target_arch = "x86_64"))]
    #[inline(always)]
    extern "C" fn abi_adapter<'s, F: IntoPrepareStackTraceCallback>(
      return_value: *mut Option<Local<'s, Value>>,
      context: Local<'s, Context>,
      error: Local<'s, Value>,
      sites: Local<'s, Array>,
    ) -> *mut Option<Local<'s, Value>> {
      unsafe {
        std::ptr::write(
          return_value,
          signature_adapter::<F>(context, error, sites),
        );
        return_value
      }
    }

    Self(abi_adapter::<F>)
  }
}

#[cfg(test)]
fn mock_prepare_stack_trace_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _error: Local<'s, Value>,
  _sites: Local<'s, Array>,
) -> Option<Local<'s, Value>> {
  unimplemented!()
}

#[test]
fn prepare_stack_trace_callback_as_type_param() {
  fn pass_as_type_param<F: IntoPrepareStackTraceCallback>(
    _: F,
  ) -> PrepareStackTraceCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_prepare_stack_trace_callback);
}

#[test]
fn prepare_stack_trace_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<PrepareStackTraceCallback>,
  ) -> PrepareStackTraceCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_prepare_stack_trace_callback);
}

#[test]
fn prepare_stack_trace_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_prepare_stack_trace_callback!(),
  ) -> PrepareStackTraceCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_prepare_stack_trace_callback);
  let _ = pass_as_impl_into_macro(|_scope, _error, _sites| unimplemented!());
}

// === PromiseHook ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn promise_hook_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   r#type: v8::PromiseHookType,
///   promise: v8::Local<'s, v8::Promise>,
///   parent: v8::Local<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct PromiseHook(RawPromiseHook);

pub trait IntoPromiseHook:
  UnitType
  + Into<PromiseHook>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    PromiseHookType,
    Local<'s, Promise>,
    Local<'s, Value>,
  )
{
}

impl<F> IntoPromiseHook for F where
  F: UnitType
    + Into<PromiseHook>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      PromiseHookType,
      Local<'s, Promise>,
      Local<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_promise_hook {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::PromiseHook>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::PromiseHookType,
      $crate::Local<'__s, $crate::Promise>,
      $crate::Local<'__s, $crate::Value>,
    )
  };
}

type RawPromiseHook =
  for<'s> extern "C" fn(PromiseHookType, Local<'s, Promise>, Local<'s, Value>);

impl<F> From<F> for PromiseHook
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      PromiseHookType,
      Local<'s, Promise>,
      Local<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoPromiseHook>(
      r#type: PromiseHookType,
      promise: Local<'s, Promise>,
      parent: Local<'s, Value>,
    ) {
      let scope = &mut unsafe { CallbackScope::new(promise) };
      (F::get())(scope, r#type, promise, parent)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_promise_hook<'s>(
  _scope: &mut HandleScope<'s>,
  _type: PromiseHookType,
  _promise: Local<'s, Promise>,
  _parent: Local<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn promise_hook_as_type_param() {
  fn pass_as_type_param<F: IntoPromiseHook>(_: F) -> PromiseHook {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_promise_hook);
}

#[test]
fn promise_hook_as_impl_into_trait() {
  fn pass_as_impl_into_trait(f: impl Into<PromiseHook>) -> PromiseHook {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_promise_hook);
}

#[test]
fn promise_hook_as_impl_into_macro() {
  fn pass_as_impl_into_macro(f: impl_into_promise_hook!()) -> PromiseHook {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_promise_hook);
  let _ = pass_as_impl_into_macro(
    |_scope, _type, _promise, _parent| unimplemented!(),
  );
}

// === PromiseRejectCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn promise_reject_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   message: v8::PromiseRejectMessage<'s>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct PromiseRejectCallback(RawPromiseRejectCallback);

pub trait IntoPromiseRejectCallback:
  UnitType
  + Into<PromiseRejectCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>, PromiseRejectMessage<'s>)
{
}

impl<F> IntoPromiseRejectCallback for F where
  F: UnitType
    + Into<PromiseRejectCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>, PromiseRejectMessage<'s>)
{
}

#[macro_export]
macro_rules! impl_into_promise_reject_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::PromiseRejectCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::PromiseRejectMessage<'__s>,
    )
  };
}

type RawPromiseRejectCallback = for<'s> extern "C" fn(PromiseRejectMessage<'s>);

impl<F> From<F> for PromiseRejectCallback
where
  F: UnitType + for<'s> FnOnce(&mut HandleScope<'s>, PromiseRejectMessage<'s>),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoPromiseRejectCallback>(
      message: PromiseRejectMessage<'s>,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&message) };
      (F::get())(scope, message)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_promise_reject_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _message: PromiseRejectMessage<'s>,
) {
  unimplemented!()
}

#[test]
fn promise_reject_callback_as_type_param() {
  fn pass_as_type_param<F: IntoPromiseRejectCallback>(
    _: F,
  ) -> PromiseRejectCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_promise_reject_callback);
}

#[test]
fn promise_reject_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<PromiseRejectCallback>,
  ) -> PromiseRejectCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_promise_reject_callback);
}

#[test]
fn promise_reject_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_promise_reject_callback!(),
  ) -> PromiseRejectCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_promise_reject_callback);
  let _ = pass_as_impl_into_macro(|_scope, _message| unimplemented!());
}

// === MicrotasksCompletedCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn microtasks_completed_callback_example(
///   isolate: &mut v8::Isolate,
///   callback_data: *mut (),
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct MicrotasksCompletedCallback(RawMicrotasksCompletedCallback);

pub trait IntoMicrotasksCompletedCallback:
  UnitType + Into<MicrotasksCompletedCallback> + FnOnce(&mut Isolate, *mut ())
{
}

impl<F> IntoMicrotasksCompletedCallback for F where
  F: UnitType
    + Into<MicrotasksCompletedCallback>
    + FnOnce(&mut Isolate, *mut ())
{
}

#[macro_export]
macro_rules! impl_into_microtasks_completed_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::MicrotasksCompletedCallback>
    + ::std::ops::FnOnce(
      &mut $crate::Isolate,
      *mut (),
    )
  };
}

type RawMicrotasksCompletedCallback = extern "C" fn(*mut Isolate, *mut c_void);

impl<F> From<F> for MicrotasksCompletedCallback
where
  F: UnitType + FnOnce(&mut Isolate, *mut ()),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoMicrotasksCompletedCallback>(
      isolate: *mut Isolate,
      callback_data: *mut c_void,
    ) {
      let isolate = unsafe { &mut *isolate };
      let callback_data = callback_data as *mut ();
      (F::get())(isolate, callback_data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_microtasks_completed_callback(
  _isolate: &mut Isolate,
  _callback_data: *mut (),
) {
  unimplemented!()
}

#[test]
fn microtasks_completed_callback_as_type_param() {
  fn pass_as_type_param<F: IntoMicrotasksCompletedCallback>(
    _: F,
  ) -> MicrotasksCompletedCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_microtasks_completed_callback);
}

#[test]
fn microtasks_completed_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<MicrotasksCompletedCallback>,
  ) -> MicrotasksCompletedCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_microtasks_completed_callback);
}

#[test]
fn microtasks_completed_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_microtasks_completed_callback!(),
  ) -> MicrotasksCompletedCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_microtasks_completed_callback);
  let _ = pass_as_impl_into_macro(|_isolate, _callback_data| unimplemented!());
}

// === MicrotaskCallback ===

/// ## Example
///
/// ```
/// fn microtask_callback_example(data: *mut ()) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct MicrotaskCallback(RawMicrotaskCallback);

pub trait IntoMicrotaskCallback:
  UnitType + Into<MicrotaskCallback> + FnOnce(*mut ())
{
}

impl<F> IntoMicrotaskCallback for F where
  F: UnitType + Into<MicrotaskCallback> + FnOnce(*mut ())
{
}

#[macro_export]
macro_rules! impl_into_microtask_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::MicrotaskCallback>
    + ::std::ops::FnOnce(
      *mut (),
    )
  };
}

type RawMicrotaskCallback = extern "C" fn(*mut c_void);

impl<F> From<F> for MicrotaskCallback
where
  F: UnitType + FnOnce(*mut ()),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoMicrotaskCallback>(data: *mut c_void) {
      let data = data as *mut ();
      (F::get())(data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_microtask_callback(_data: *mut ()) {
  unimplemented!()
}

#[test]
fn microtask_callback_as_type_param() {
  fn pass_as_type_param<F: IntoMicrotaskCallback>(_: F) -> MicrotaskCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_microtask_callback);
}

#[test]
fn microtask_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<MicrotaskCallback>,
  ) -> MicrotaskCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_microtask_callback);
}

#[test]
fn microtask_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_microtask_callback!(),
  ) -> MicrotaskCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_microtask_callback);
  let _ = pass_as_impl_into_macro(|_data| unimplemented!());
}

// === FailedAccessCheckCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn failed_access_check_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   target: v8::Local<'s, v8::Object>,
///   r#type: v8::AccessType,
///   data: v8::Local<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct FailedAccessCheckCallback(RawFailedAccessCheckCallback);

pub trait IntoFailedAccessCheckCallback:
  UnitType
  + Into<FailedAccessCheckCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Object>,
    AccessType,
    Local<'s, Value>,
  )
{
}

impl<F> IntoFailedAccessCheckCallback for F where
  F: UnitType
    + Into<FailedAccessCheckCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      AccessType,
      Local<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_failed_access_check_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::FailedAccessCheckCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Object>,
      $crate::AccessType,
      $crate::Local<'__s, $crate::Value>,
    )
  };
}

type RawFailedAccessCheckCallback =
  for<'s> extern "C" fn(Local<'s, Object>, AccessType, Local<'s, Value>);

impl<F> From<F> for FailedAccessCheckCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      AccessType,
      Local<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoFailedAccessCheckCallback>(
      target: Local<'s, Object>,
      r#type: AccessType,
      data: Local<'s, Value>,
    ) {
      let scope = &mut unsafe { CallbackScope::new(target) };
      (F::get())(scope, target, r#type, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_failed_access_check_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _target: Local<'s, Object>,
  _type: AccessType,
  _data: Local<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn failed_access_check_callback_as_type_param() {
  fn pass_as_type_param<F: IntoFailedAccessCheckCallback>(
    _: F,
  ) -> FailedAccessCheckCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_failed_access_check_callback);
}

#[test]
fn failed_access_check_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<FailedAccessCheckCallback>,
  ) -> FailedAccessCheckCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_failed_access_check_callback);
}

#[test]
fn failed_access_check_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_failed_access_check_callback!(),
  ) -> FailedAccessCheckCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_failed_access_check_callback);
  let _ =
    pass_as_impl_into_macro(|_scope, _target, _type, _data| unimplemented!());
}

/// Callback to check if code generation from strings is allowed. See
/// Context::AllowCodeGenerationFromStrings.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn allow_code_generation_from_strings_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   source: v8::Local<'s, v8::String>,
/// ) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AllowCodeGenerationFromStringsCallback(
  RawAllowCodeGenerationFromStringsCallback,
);

pub trait IntoAllowCodeGenerationFromStringsCallback:
  UnitType
  + Into<AllowCodeGenerationFromStringsCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, String>) -> bool
{
}

impl<F> IntoAllowCodeGenerationFromStringsCallback for F where
  F: UnitType
    + Into<AllowCodeGenerationFromStringsCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, String>) -> bool
{
}

#[macro_export]
macro_rules! impl_into_allow_code_generation_from_strings_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AllowCodeGenerationFromStringsCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::String>,
    ) -> bool
  };
}

type RawAllowCodeGenerationFromStringsCallback =
  for<'s> extern "C" fn(Local<'s, Context>, Local<'s, String>) -> bool;

impl<F> From<F> for AllowCodeGenerationFromStringsCallback
where
  F: UnitType + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, String>) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAllowCodeGenerationFromStringsCallback>(
      context: Local<'s, Context>,
      source: Local<'s, String>,
    ) -> bool {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, source)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_allow_code_generation_from_strings_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _source: Local<'s, String>,
) -> bool {
  unimplemented!()
}

#[test]
fn allow_code_generation_from_strings_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAllowCodeGenerationFromStringsCallback>(
    _: F,
  ) -> AllowCodeGenerationFromStringsCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_allow_code_generation_from_strings_callback);
}

#[test]
fn allow_code_generation_from_strings_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AllowCodeGenerationFromStringsCallback>,
  ) -> AllowCodeGenerationFromStringsCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_trait(mock_allow_code_generation_from_strings_callback);
}

#[test]
fn allow_code_generation_from_strings_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_allow_code_generation_from_strings_callback!(),
  ) -> AllowCodeGenerationFromStringsCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_macro(mock_allow_code_generation_from_strings_callback);
  let _ = pass_as_impl_into_macro(|_scope, _source| unimplemented!());
}

/// Callback to check if codegen is allowed from a source object, and convert
/// the source to string if necessary.See  ModifyCodeGenerationFromStrings.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn modify_code_generation_from_strings_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   source: v8::Local<'s, v8::Value>,
/// ) -> v8::ModifyCodeGenerationFromStringsResult<'s> {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct ModifyCodeGenerationFromStringsCallback(
  RawModifyCodeGenerationFromStringsCallback,
);

pub trait IntoModifyCodeGenerationFromStringsCallback:
  UnitType
  + Into<ModifyCodeGenerationFromStringsCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Value>,
  ) -> ModifyCodeGenerationFromStringsResult<'s>
{
}

impl<F> IntoModifyCodeGenerationFromStringsCallback for F where
  F: UnitType
    + Into<ModifyCodeGenerationFromStringsCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Value>,
    ) -> ModifyCodeGenerationFromStringsResult<'s>
{
}

#[macro_export]
macro_rules! impl_into_modify_code_generation_from_strings_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::ModifyCodeGenerationFromStringsCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Value>,
    ) -> $crate::ModifyCodeGenerationFromStringsResult<'__s>
  };
}

#[cfg(target_family = "unix")]
type RawModifyCodeGenerationFromStringsCallback =
  for<'s> extern "C" fn(
    Local<'s, Context>,
    Local<'s, Value>,
  ) -> ModifyCodeGenerationFromStringsResult<'s>;

#[cfg(all(target_family = "windows", target_arch = "x86_64"))]
type RawModifyCodeGenerationFromStringsCallback =
  for<'s> extern "C" fn(
    *mut ModifyCodeGenerationFromStringsResult<'s>,
    Local<'s, Context>,
    Local<'s, Value>,
  ) -> *mut ModifyCodeGenerationFromStringsResult<'s>;

impl<F> From<F> for ModifyCodeGenerationFromStringsCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Value>,
    ) -> ModifyCodeGenerationFromStringsResult<'s>,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    fn signature_adapter<'s, F: IntoModifyCodeGenerationFromStringsCallback>(
      context: Local<'s, Context>,
      source: Local<'s, Value>,
    ) -> ModifyCodeGenerationFromStringsResult<'s> {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, source)
    }

    #[cfg(target_family = "unix")]
    #[inline(always)]
    extern "C" fn abi_adapter<
      's,
      F: IntoModifyCodeGenerationFromStringsCallback,
    >(
      context: Local<'s, Context>,
      source: Local<'s, Value>,
    ) -> ModifyCodeGenerationFromStringsResult<'s> {
      signature_adapter::<F>(context, source)
    }

    #[cfg(all(target_family = "windows", target_arch = "x86_64"))]
    #[inline(always)]
    extern "C" fn abi_adapter<
      's,
      F: IntoModifyCodeGenerationFromStringsCallback,
    >(
      return_value: *mut ModifyCodeGenerationFromStringsResult<'s>,
      context: Local<'s, Context>,
      source: Local<'s, Value>,
    ) -> *mut ModifyCodeGenerationFromStringsResult<'s> {
      unsafe {
        std::ptr::write(return_value, signature_adapter::<F>(context, source));
        return_value
      }
    }

    Self(abi_adapter::<F>)
  }
}

#[cfg(test)]
fn mock_modify_code_generation_from_strings_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _source: Local<'s, Value>,
) -> ModifyCodeGenerationFromStringsResult<'s> {
  unimplemented!()
}

#[test]
fn modify_code_generation_from_strings_callback_as_type_param() {
  fn pass_as_type_param<F: IntoModifyCodeGenerationFromStringsCallback>(
    _: F,
  ) -> ModifyCodeGenerationFromStringsCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_modify_code_generation_from_strings_callback);
}

#[test]
fn modify_code_generation_from_strings_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<ModifyCodeGenerationFromStringsCallback>,
  ) -> ModifyCodeGenerationFromStringsCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_trait(mock_modify_code_generation_from_strings_callback);
}

#[test]
fn modify_code_generation_from_strings_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_modify_code_generation_from_strings_callback!(),
  ) -> ModifyCodeGenerationFromStringsCallback {
    f.into()
  }
  let _ =
    pass_as_impl_into_macro(mock_modify_code_generation_from_strings_callback);
  let _ = pass_as_impl_into_macro(|_scope, _source| unimplemented!());
}

// === ExtensionCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn extension_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   arguments: v8::FunctionCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct ExtensionCallback(RawExtensionCallback);

pub trait IntoExtensionCallback:
  UnitType
  + Into<ExtensionCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    FunctionCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  ) -> bool
{
}

impl<F> IntoExtensionCallback for F where
  F: UnitType
    + Into<ExtensionCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ) -> bool
{
}

#[macro_export]
macro_rules! impl_into_extension_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::ExtensionCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::FunctionCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    ) -> bool
  };
}

type RawExtensionCallback = extern "C" fn(*const FunctionCallbackInfo) -> bool;

impl<F> From<F> for ExtensionCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoExtensionCallback>(
      info: *const FunctionCallbackInfo,
    ) -> bool {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        FunctionCallbackArguments::from_function_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_function_callback_info(info);
      (F::get())(scope, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_extension_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _arguments: FunctionCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) -> bool {
  unimplemented!()
}

#[test]
fn extension_callback_as_type_param() {
  fn pass_as_type_param<F: IntoExtensionCallback>(_: F) -> ExtensionCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_extension_callback);
}

#[test]
fn extension_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<ExtensionCallback>,
  ) -> ExtensionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_extension_callback);
}

#[test]
fn extension_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_extension_callback!(),
  ) -> ExtensionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_extension_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _arguments, _return_value| unimplemented!(),
  );
}

// === AllowWasmCodeGenerationCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn allow_wasm_code_generation_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   source: v8::Local<'s, v8::String>,
/// ) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AllowWasmCodeGenerationCallback(RawAllowWasmCodeGenerationCallback);

pub trait IntoAllowWasmCodeGenerationCallback:
  UnitType
  + Into<AllowWasmCodeGenerationCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, String>) -> bool
{
}

impl<F> IntoAllowWasmCodeGenerationCallback for F where
  F: UnitType
    + Into<AllowWasmCodeGenerationCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, String>) -> bool
{
}

#[macro_export]
macro_rules! impl_into_allow_wasm_code_generation_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AllowWasmCodeGenerationCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::String>,
    ) -> bool
  };
}

type RawAllowWasmCodeGenerationCallback =
  for<'s> extern "C" fn(Local<'s, Context>, Local<'s, String>) -> bool;

impl<F> From<F> for AllowWasmCodeGenerationCallback
where
  F: UnitType + for<'s> FnOnce(&mut HandleScope<'s>, Local<'s, String>) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAllowWasmCodeGenerationCallback>(
      context: Local<'s, Context>,
      source: Local<'s, String>,
    ) -> bool {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope, source)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_allow_wasm_code_generation_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _source: Local<'s, String>,
) -> bool {
  unimplemented!()
}

#[test]
fn allow_wasm_code_generation_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAllowWasmCodeGenerationCallback>(
    _: F,
  ) -> AllowWasmCodeGenerationCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_allow_wasm_code_generation_callback);
}

#[test]
fn allow_wasm_code_generation_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AllowWasmCodeGenerationCallback>,
  ) -> AllowWasmCodeGenerationCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_allow_wasm_code_generation_callback);
}

#[test]
fn allow_wasm_code_generation_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_allow_wasm_code_generation_callback!(),
  ) -> AllowWasmCodeGenerationCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_allow_wasm_code_generation_callback);
  let _ = pass_as_impl_into_macro(|_scope, _source| unimplemented!());
}

// === ApiImplementationCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn api_implementation_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   arguments: v8::FunctionCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct ApiImplementationCallback(RawApiImplementationCallback);

pub trait IntoApiImplementationCallback:
  UnitType
  + Into<ApiImplementationCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    FunctionCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoApiImplementationCallback for F where
  F: UnitType
    + Into<ApiImplementationCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_api_implementation_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::ApiImplementationCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::FunctionCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawApiImplementationCallback = extern "C" fn(*const FunctionCallbackInfo);

impl<F> From<F> for ApiImplementationCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoApiImplementationCallback>(
      info: *const FunctionCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        FunctionCallbackArguments::from_function_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_function_callback_info(info);
      (F::get())(scope, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_api_implementation_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _arguments: FunctionCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn api_implementation_callback_as_type_param() {
  fn pass_as_type_param<F: IntoApiImplementationCallback>(
    _: F,
  ) -> ApiImplementationCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_api_implementation_callback);
}

#[test]
fn api_implementation_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<ApiImplementationCallback>,
  ) -> ApiImplementationCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_api_implementation_callback);
}

#[test]
fn api_implementation_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_api_implementation_callback!(),
  ) -> ApiImplementationCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_api_implementation_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _arguments, _return_value| unimplemented!(),
  );
}

// === WasmStreamingCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn wasm_streaming_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   arguments: v8::FunctionCallbackArguments<'s>,
///   return_value: v8::ReturnValue<'s, v8::Value>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct WasmStreamingCallback(RawWasmStreamingCallback);

pub trait IntoWasmStreamingCallback:
  UnitType
  + Into<WasmStreamingCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    FunctionCallbackArguments<'s>,
    ReturnValue<'s, Value>,
  )
{
}

impl<F> IntoWasmStreamingCallback for F where
  F: UnitType
    + Into<WasmStreamingCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    )
{
}

#[macro_export]
macro_rules! impl_into_wasm_streaming_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::WasmStreamingCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::FunctionCallbackArguments<'__s>,
      $crate::ReturnValue<'__s, $crate::Value>,
    )
  };
}

type RawWasmStreamingCallback = extern "C" fn(*const FunctionCallbackInfo);

impl<F> From<F> for WasmStreamingCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      FunctionCallbackArguments<'s>,
      ReturnValue<'s, Value>,
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoWasmStreamingCallback>(
      info: *const FunctionCallbackInfo,
    ) {
      let scope = &mut unsafe { CallbackScope::new(&*info) };
      let arguments =
        FunctionCallbackArguments::from_function_callback_info(info);
      let return_value =
        ReturnValue::<Value>::from_function_callback_info(info);
      (F::get())(scope, arguments, return_value)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_wasm_streaming_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _arguments: FunctionCallbackArguments<'s>,
  _return_value: ReturnValue<'s, Value>,
) {
  unimplemented!()
}

#[test]
fn wasm_streaming_callback_as_type_param() {
  fn pass_as_type_param<F: IntoWasmStreamingCallback>(
    _: F,
  ) -> WasmStreamingCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_wasm_streaming_callback);
}

#[test]
fn wasm_streaming_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<WasmStreamingCallback>,
  ) -> WasmStreamingCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_wasm_streaming_callback);
}

#[test]
fn wasm_streaming_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_wasm_streaming_callback!(),
  ) -> WasmStreamingCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_wasm_streaming_callback);
  let _ = pass_as_impl_into_macro(
    |_scope, _arguments, _return_value| unimplemented!(),
  );
}

// === WasmThreadsEnabledCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn wasm_threads_enabled_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
/// ) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct WasmThreadsEnabledCallback(RawWasmThreadsEnabledCallback);

pub trait IntoWasmThreadsEnabledCallback:
  UnitType
  + Into<WasmThreadsEnabledCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>) -> bool
{
}

impl<F> IntoWasmThreadsEnabledCallback for F where
  F: UnitType
    + Into<WasmThreadsEnabledCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>) -> bool
{
}

#[macro_export]
macro_rules! impl_into_wasm_threads_enabled_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::WasmThreadsEnabledCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
    ) -> bool
  };
}

type RawWasmThreadsEnabledCallback =
  for<'s> extern "C" fn(Local<'s, Context>) -> bool;

impl<F> From<F> for WasmThreadsEnabledCallback
where
  F: UnitType + for<'s> FnOnce(&mut HandleScope<'s>) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoWasmThreadsEnabledCallback>(
      context: Local<'s, Context>,
    ) -> bool {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_wasm_threads_enabled_callback<'s>(
  _scope: &mut HandleScope<'s>,
) -> bool {
  unimplemented!()
}

#[test]
fn wasm_threads_enabled_callback_as_type_param() {
  fn pass_as_type_param<F: IntoWasmThreadsEnabledCallback>(
    _: F,
  ) -> WasmThreadsEnabledCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_wasm_threads_enabled_callback);
}

#[test]
fn wasm_threads_enabled_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<WasmThreadsEnabledCallback>,
  ) -> WasmThreadsEnabledCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_wasm_threads_enabled_callback);
}

#[test]
fn wasm_threads_enabled_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_wasm_threads_enabled_callback!(),
  ) -> WasmThreadsEnabledCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_wasm_threads_enabled_callback);
  let _ = pass_as_impl_into_macro(|_scope| unimplemented!());
}

// === WasmLoadSourceMapCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// # use std::ffi::CStr;
/// #
/// fn wasm_load_source_map_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s, ()>,
///   name: &CStr,
/// ) -> v8::Local<'s, v8::String> {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct WasmLoadSourceMapCallback(RawWasmLoadSourceMapCallback);

pub trait IntoWasmLoadSourceMapCallback:
  UnitType
  + Into<WasmLoadSourceMapCallback>
  + for<'s> FnOnce(&mut HandleScope<'s, ()>, &CStr) -> Local<'s, String>
{
}

impl<F> IntoWasmLoadSourceMapCallback for F where
  F: UnitType
    + Into<WasmLoadSourceMapCallback>
    + for<'s> FnOnce(&mut HandleScope<'s, ()>, &CStr) -> Local<'s, String>
{
}

#[macro_export]
macro_rules! impl_into_wasm_load_source_map_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::WasmLoadSourceMapCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s, ()>,
      &::std::ffi::CStr,
    ) -> $crate::Local<'__s, $crate::String>
  };
}

#[cfg(target_family = "unix")]
type RawWasmLoadSourceMapCallback =
  extern "C" fn(*mut Isolate, *const c_char) -> Local<'static, String>;

#[cfg(all(target_family = "windows", target_arch = "x86_64"))]
type RawWasmLoadSourceMapCallback =
  for<'s> extern "C" fn(
    *mut Local<'s, String>,
    *mut Isolate,
    *const c_char,
  ) -> *mut Local<'s, String>;

impl<F> From<F> for WasmLoadSourceMapCallback
where
  F: UnitType
    + for<'s> FnOnce(&mut HandleScope<'s, ()>, &CStr) -> Local<'s, String>,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    fn signature_adapter<F: IntoWasmLoadSourceMapCallback>(
      isolate: *mut Isolate,
      name: *const c_char,
    ) -> Local<'static, String> {
      let scope = &mut unsafe { CallbackScope::new(&mut *isolate) };
      let name = unsafe { CStr::from_ptr(name) };
      (F::get())(scope, name)
    }

    #[cfg(target_family = "unix")]
    #[inline(always)]
    extern "C" fn abi_adapter<F: IntoWasmLoadSourceMapCallback>(
      isolate: *mut Isolate,
      name: *const c_char,
    ) -> Local<'static, String> {
      signature_adapter::<F>(isolate, name)
    }

    #[cfg(all(target_family = "windows", target_arch = "x86_64"))]
    #[inline(always)]
    extern "C" fn abi_adapter<'s, F: IntoWasmLoadSourceMapCallback>(
      return_value: *mut Local<'s, String>,
      isolate: *mut Isolate,
      name: *const c_char,
    ) -> *mut Local<'s, String> {
      unsafe {
        std::ptr::write(return_value, signature_adapter::<F>(isolate, name));
        return_value
      }
    }

    Self(abi_adapter::<F>)
  }
}

#[cfg(test)]
fn mock_wasm_load_source_map_callback<'s>(
  _scope: &mut HandleScope<'s, ()>,
  _name: &CStr,
) -> Local<'s, String> {
  unimplemented!()
}

#[test]
fn wasm_load_source_map_callback_as_type_param() {
  fn pass_as_type_param<F: IntoWasmLoadSourceMapCallback>(
    _: F,
  ) -> WasmLoadSourceMapCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_wasm_load_source_map_callback);
}

#[test]
fn wasm_load_source_map_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<WasmLoadSourceMapCallback>,
  ) -> WasmLoadSourceMapCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_wasm_load_source_map_callback);
}

#[test]
fn wasm_load_source_map_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_wasm_load_source_map_callback!(),
  ) -> WasmLoadSourceMapCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_wasm_load_source_map_callback);
  let _ = pass_as_impl_into_macro(|_scope, _name| unimplemented!());
}

// === WasmSimdEnabledCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn wasm_simd_enabled_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
/// ) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct WasmSimdEnabledCallback(RawWasmSimdEnabledCallback);

pub trait IntoWasmSimdEnabledCallback:
  UnitType
  + Into<WasmSimdEnabledCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>) -> bool
{
}

impl<F> IntoWasmSimdEnabledCallback for F where
  F: UnitType
    + Into<WasmSimdEnabledCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>) -> bool
{
}

#[macro_export]
macro_rules! impl_into_wasm_simd_enabled_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::WasmSimdEnabledCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
    ) -> bool
  };
}

type RawWasmSimdEnabledCallback =
  for<'s> extern "C" fn(Local<'s, Context>) -> bool;

impl<F> From<F> for WasmSimdEnabledCallback
where
  F: UnitType + for<'s> FnOnce(&mut HandleScope<'s>) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoWasmSimdEnabledCallback>(
      context: Local<'s, Context>,
    ) -> bool {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_wasm_simd_enabled_callback<'s>(_scope: &mut HandleScope<'s>) -> bool {
  unimplemented!()
}

#[test]
fn wasm_simd_enabled_callback_as_type_param() {
  fn pass_as_type_param<F: IntoWasmSimdEnabledCallback>(
    _: F,
  ) -> WasmSimdEnabledCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_wasm_simd_enabled_callback);
}

#[test]
fn wasm_simd_enabled_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<WasmSimdEnabledCallback>,
  ) -> WasmSimdEnabledCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_wasm_simd_enabled_callback);
}

#[test]
fn wasm_simd_enabled_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_wasm_simd_enabled_callback!(),
  ) -> WasmSimdEnabledCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_wasm_simd_enabled_callback);
  let _ = pass_as_impl_into_macro(|_scope| unimplemented!());
}

// === InterruptCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn interrupt_callback_example(isolate: &mut v8::Isolate, data: *mut ()) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct InterruptCallback(RawInterruptCallback);

pub trait IntoInterruptCallback:
  UnitType + Into<InterruptCallback> + FnOnce(&mut Isolate, *mut ())
{
}

impl<F> IntoInterruptCallback for F where
  F: UnitType + Into<InterruptCallback> + FnOnce(&mut Isolate, *mut ())
{
}

#[macro_export]
macro_rules! impl_into_interrupt_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::InterruptCallback>
    + ::std::ops::FnOnce(
      &mut $crate::Isolate,
      *mut (),
    )
  };
}

type RawInterruptCallback = extern "C" fn(*mut Isolate, *mut c_void);

impl<F> From<F> for InterruptCallback
where
  F: UnitType + FnOnce(&mut Isolate, *mut ()),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoInterruptCallback>(
      isolate: *mut Isolate,
      data: *mut c_void,
    ) {
      let isolate = unsafe { &mut *isolate };
      let data = data as *mut ();
      (F::get())(isolate, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_interrupt_callback(_isolate: &mut Isolate, _data: *mut ()) {
  unimplemented!()
}

#[test]
fn interrupt_callback_as_type_param() {
  fn pass_as_type_param<F: IntoInterruptCallback>(_: F) -> InterruptCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_interrupt_callback);
}

#[test]
fn interrupt_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<InterruptCallback>,
  ) -> InterruptCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_interrupt_callback);
}

#[test]
fn interrupt_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_interrupt_callback!(),
  ) -> InterruptCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_interrupt_callback);
  let _ = pass_as_impl_into_macro(|_isolate, _data| unimplemented!());
}

/// This callback is invoked when the heap size is close to the heap limit and
/// V8 is likely to abort with out-of-memory error.
/// The callback can extend the heap limit by returning a value that is greater
/// than the current_heap_limit. The initial heap limit is the limit that was
/// set after heap setup.
///
/// ## Example
///
/// ```
/// fn near_heap_limit_callback_example(
///   current_heap_limit: usize,
///   initial_heap_limit: usize,
///   data: *mut (),
/// ) -> usize {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct NearHeapLimitCallback(RawNearHeapLimitCallback);

pub trait IntoNearHeapLimitCallback:
  UnitType + Into<NearHeapLimitCallback> + FnOnce(usize, usize, *mut ()) -> usize
{
}

impl<F> IntoNearHeapLimitCallback for F where
  F: UnitType
    + Into<NearHeapLimitCallback>
    + FnOnce(usize, usize, *mut ()) -> usize
{
}

#[macro_export]
macro_rules! impl_into_near_heap_limit_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::NearHeapLimitCallback>
    + ::std::ops::FnOnce(
      usize,
      usize,
      *mut (),
    ) -> usize
  };
}

type RawNearHeapLimitCallback =
  extern "C" fn(*mut c_void, usize, usize) -> usize;

impl<F> From<F> for NearHeapLimitCallback
where
  F: UnitType + FnOnce(usize, usize, *mut ()) -> usize,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoNearHeapLimitCallback>(
      data: *mut c_void,
      current_heap_limit: usize,
      initial_heap_limit: usize,
    ) -> usize {
      let data = data as *mut ();
      (F::get())(current_heap_limit, initial_heap_limit, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_near_heap_limit_callback(
  _current_heap_limit: usize,
  _initial_heap_limit: usize,
  _data: *mut (),
) -> usize {
  unimplemented!()
}

#[test]
fn near_heap_limit_callback_as_type_param() {
  fn pass_as_type_param<F: IntoNearHeapLimitCallback>(
    _: F,
  ) -> NearHeapLimitCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_near_heap_limit_callback);
}

#[test]
fn near_heap_limit_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<NearHeapLimitCallback>,
  ) -> NearHeapLimitCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_near_heap_limit_callback);
}

#[test]
fn near_heap_limit_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_near_heap_limit_callback!(),
  ) -> NearHeapLimitCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_near_heap_limit_callback);
  let _ = pass_as_impl_into_macro(
    |_current_heap_limit, _initial_heap_limit, _data| unimplemented!(),
  );
}

/// Callback function passed to SetJitCodeEventHandler.
///
/// \param event code add, move or removal event.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn jit_code_event_handler_example(event: &v8::JitCodeEvent) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct JitCodeEventHandler(RawJitCodeEventHandler);

pub trait IntoJitCodeEventHandler:
  UnitType + Into<JitCodeEventHandler> + FnOnce(&JitCodeEvent)
{
}

impl<F> IntoJitCodeEventHandler for F where
  F: UnitType + Into<JitCodeEventHandler> + FnOnce(&JitCodeEvent)
{
}

#[macro_export]
macro_rules! impl_into_jit_code_event_handler {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::JitCodeEventHandler>
    + ::std::ops::FnOnce(
      &$crate::JitCodeEvent,
    )
  };
}

type RawJitCodeEventHandler = extern "C" fn(*const JitCodeEvent);

impl<F> From<F> for JitCodeEventHandler
where
  F: UnitType + FnOnce(&JitCodeEvent),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoJitCodeEventHandler>(
      event: *const JitCodeEvent,
    ) {
      let event = unsafe { &*event };
      (F::get())(event)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_jit_code_event_handler(_event: &JitCodeEvent) {
  unimplemented!()
}

#[test]
fn jit_code_event_handler_as_type_param() {
  fn pass_as_type_param<F: IntoJitCodeEventHandler>(
    _: F,
  ) -> JitCodeEventHandler {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_jit_code_event_handler);
}

#[test]
fn jit_code_event_handler_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<JitCodeEventHandler>,
  ) -> JitCodeEventHandler {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_jit_code_event_handler);
}

#[test]
fn jit_code_event_handler_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_jit_code_event_handler!(),
  ) -> JitCodeEventHandler {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_jit_code_event_handler);
  let _ = pass_as_impl_into_macro(|_event| unimplemented!());
}

// === SerializeInternalFieldsCallbackFn ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn serialize_internal_fields_callback_fn_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   holder: v8::Local<'s, v8::Object>,
///   index: i32,
///   data: *mut (),
/// ) -> v8::StartupData {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct SerializeInternalFieldsCallbackFn(
  RawSerializeInternalFieldsCallbackFn,
);

pub trait IntoSerializeInternalFieldsCallbackFn:
  UnitType
  + Into<SerializeInternalFieldsCallbackFn>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Object>,
    i32,
    *mut (),
  ) -> StartupData
{
}

impl<F> IntoSerializeInternalFieldsCallbackFn for F where
  F: UnitType
    + Into<SerializeInternalFieldsCallbackFn>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      i32,
      *mut (),
    ) -> StartupData
{
}

#[macro_export]
macro_rules! impl_into_serialize_internal_fields_callback_fn {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::SerializeInternalFieldsCallbackFn>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Object>,
      i32,
      *mut (),
    ) -> $crate::StartupData
  };
}

type RawSerializeInternalFieldsCallbackFn =
  for<'s> extern "C" fn(Local<'s, Object>, c_int, *mut c_void) -> StartupData;

impl<F> From<F> for SerializeInternalFieldsCallbackFn
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      i32,
      *mut (),
    ) -> StartupData,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoSerializeInternalFieldsCallbackFn>(
      holder: Local<'s, Object>,
      index: c_int,
      data: *mut c_void,
    ) -> StartupData {
      let scope = &mut unsafe { CallbackScope::new(holder) };
      let data = data as *mut ();
      (F::get())(scope, holder, index, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_serialize_internal_fields_callback_fn<'s>(
  _scope: &mut HandleScope<'s>,
  _holder: Local<'s, Object>,
  _index: i32,
  _data: *mut (),
) -> StartupData {
  unimplemented!()
}

#[test]
fn serialize_internal_fields_callback_fn_as_type_param() {
  fn pass_as_type_param<F: IntoSerializeInternalFieldsCallbackFn>(
    _: F,
  ) -> SerializeInternalFieldsCallbackFn {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_serialize_internal_fields_callback_fn);
}

#[test]
fn serialize_internal_fields_callback_fn_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<SerializeInternalFieldsCallbackFn>,
  ) -> SerializeInternalFieldsCallbackFn {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_serialize_internal_fields_callback_fn);
}

#[test]
fn serialize_internal_fields_callback_fn_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_serialize_internal_fields_callback_fn!(),
  ) -> SerializeInternalFieldsCallbackFn {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_serialize_internal_fields_callback_fn);
  let _ =
    pass_as_impl_into_macro(|_scope, _holder, _index, _data| unimplemented!());
}

// === DeserializeInternalFieldsCallbackFn ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn deserialize_internal_fields_callback_fn_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   holder: v8::Local<'s, v8::Object>,
///   index: i32,
///   payload: v8::StartupData,
///   data: *mut (),
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct DeserializeInternalFieldsCallbackFn(
  RawDeserializeInternalFieldsCallbackFn,
);

pub trait IntoDeserializeInternalFieldsCallbackFn:
  UnitType
  + Into<DeserializeInternalFieldsCallbackFn>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    Local<'s, Object>,
    i32,
    StartupData,
    *mut (),
  )
{
}

impl<F> IntoDeserializeInternalFieldsCallbackFn for F where
  F: UnitType
    + Into<DeserializeInternalFieldsCallbackFn>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      i32,
      StartupData,
      *mut (),
    )
{
}

#[macro_export]
macro_rules! impl_into_deserialize_internal_fields_callback_fn {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::DeserializeInternalFieldsCallbackFn>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::Local<'__s, $crate::Object>,
      i32,
      $crate::StartupData,
      *mut (),
    )
  };
}

type RawDeserializeInternalFieldsCallbackFn =
  for<'s> extern "C" fn(Local<'s, Object>, c_int, StartupData, *mut c_void);

impl<F> From<F> for DeserializeInternalFieldsCallbackFn
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      Local<'s, Object>,
      i32,
      StartupData,
      *mut (),
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoDeserializeInternalFieldsCallbackFn>(
      holder: Local<'s, Object>,
      index: c_int,
      payload: StartupData,
      data: *mut c_void,
    ) {
      let scope = &mut unsafe { CallbackScope::new(holder) };
      let data = data as *mut ();
      (F::get())(scope, holder, index, payload, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_deserialize_internal_fields_callback_fn<'s>(
  _scope: &mut HandleScope<'s>,
  _holder: Local<'s, Object>,
  _index: i32,
  _payload: StartupData,
  _data: *mut (),
) {
  unimplemented!()
}

#[test]
fn deserialize_internal_fields_callback_fn_as_type_param() {
  fn pass_as_type_param<F: IntoDeserializeInternalFieldsCallbackFn>(
    _: F,
  ) -> DeserializeInternalFieldsCallbackFn {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_deserialize_internal_fields_callback_fn);
}

#[test]
fn deserialize_internal_fields_callback_fn_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<DeserializeInternalFieldsCallbackFn>,
  ) -> DeserializeInternalFieldsCallbackFn {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_deserialize_internal_fields_callback_fn);
}

#[test]
fn deserialize_internal_fields_callback_fn_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_deserialize_internal_fields_callback_fn!(),
  ) -> DeserializeInternalFieldsCallbackFn {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_deserialize_internal_fields_callback_fn);
  let _ = pass_as_impl_into_macro(
    |_scope, _holder, _index, _payload, _data| unimplemented!(),
  );
}

// === UseCounterCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn use_counter_callback_example(
///   isolate: &mut v8::Isolate,
///   feature: v8::UseCounterFeature,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct UseCounterCallback(RawUseCounterCallback);

pub trait IntoUseCounterCallback:
  UnitType + Into<UseCounterCallback> + FnOnce(&mut Isolate, UseCounterFeature)
{
}

impl<F> IntoUseCounterCallback for F where
  F: UnitType
    + Into<UseCounterCallback>
    + FnOnce(&mut Isolate, UseCounterFeature)
{
}

#[macro_export]
macro_rules! impl_into_use_counter_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::UseCounterCallback>
    + ::std::ops::FnOnce(
      &mut $crate::Isolate,
      $crate::UseCounterFeature,
    )
  };
}

type RawUseCounterCallback = extern "C" fn(*mut Isolate, UseCounterFeature);

impl<F> From<F> for UseCounterCallback
where
  F: UnitType + FnOnce(&mut Isolate, UseCounterFeature),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoUseCounterCallback>(
      isolate: *mut Isolate,
      feature: UseCounterFeature,
    ) {
      let isolate = unsafe { &mut *isolate };
      (F::get())(isolate, feature)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_use_counter_callback(
  _isolate: &mut Isolate,
  _feature: UseCounterFeature,
) {
  unimplemented!()
}

#[test]
fn use_counter_callback_as_type_param() {
  fn pass_as_type_param<F: IntoUseCounterCallback>(_: F) -> UseCounterCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_use_counter_callback);
}

#[test]
fn use_counter_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<UseCounterCallback>,
  ) -> UseCounterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_use_counter_callback);
}

#[test]
fn use_counter_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_use_counter_callback!(),
  ) -> UseCounterCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_use_counter_callback);
  let _ = pass_as_impl_into_macro(|_isolate, _feature| unimplemented!());
}

/// Custom callback used by embedders to help V8 determine if it should abort
/// when it throws and no internal handler is predicted to catch the
/// exception. If --abort-on-uncaught-exception is used on the command line,
/// then V8 will abort if either:
/// - no custom callback is set.
/// - the custom callback set returns true.
/// Otherwise, the custom callback will not be called and V8 will not abort.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn abort_on_uncaught_exception_callback_example(
///   isolate: &mut v8::Isolate,
/// ) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AbortOnUncaughtExceptionCallback(
  RawAbortOnUncaughtExceptionCallback,
);

pub trait IntoAbortOnUncaughtExceptionCallback:
  UnitType + Into<AbortOnUncaughtExceptionCallback> + FnOnce(&mut Isolate) -> bool
{
}

impl<F> IntoAbortOnUncaughtExceptionCallback for F where
  F: UnitType
    + Into<AbortOnUncaughtExceptionCallback>
    + FnOnce(&mut Isolate) -> bool
{
}

#[macro_export]
macro_rules! impl_into_abort_on_uncaught_exception_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AbortOnUncaughtExceptionCallback>
    + ::std::ops::FnOnce(
      &mut $crate::Isolate,
    ) -> bool
  };
}

type RawAbortOnUncaughtExceptionCallback = extern "C" fn(*mut Isolate) -> bool;

impl<F> From<F> for AbortOnUncaughtExceptionCallback
where
  F: UnitType + FnOnce(&mut Isolate) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoAbortOnUncaughtExceptionCallback>(
      isolate: *mut Isolate,
    ) -> bool {
      let isolate = unsafe { &mut *isolate };
      (F::get())(isolate)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_abort_on_uncaught_exception_callback(_isolate: &mut Isolate) -> bool {
  unimplemented!()
}

#[test]
fn abort_on_uncaught_exception_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAbortOnUncaughtExceptionCallback>(
    _: F,
  ) -> AbortOnUncaughtExceptionCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_abort_on_uncaught_exception_callback);
}

#[test]
fn abort_on_uncaught_exception_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AbortOnUncaughtExceptionCallback>,
  ) -> AbortOnUncaughtExceptionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_abort_on_uncaught_exception_callback);
}

#[test]
fn abort_on_uncaught_exception_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_abort_on_uncaught_exception_callback!(),
  ) -> AbortOnUncaughtExceptionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_abort_on_uncaught_exception_callback);
  let _ = pass_as_impl_into_macro(|_isolate| unimplemented!());
}

// === GCCallback ===

/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn gc_callback_example(
///   isolate: &mut v8::Isolate,
///   r#type: v8::GCType,
///   flags: v8::GCCallbackFlags,
///   data: *mut (),
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GCCallback(RawGCCallback);

pub trait IntoGCCallback:
  UnitType
  + Into<GCCallback>
  + FnOnce(&mut Isolate, GCType, GCCallbackFlags, *mut ())
{
}

impl<F> IntoGCCallback for F where
  F: UnitType
    + Into<GCCallback>
    + FnOnce(&mut Isolate, GCType, GCCallbackFlags, *mut ())
{
}

#[macro_export]
macro_rules! impl_into_gc_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GCCallback>
    + ::std::ops::FnOnce(
      &mut $crate::Isolate,
      $crate::GCType,
      $crate::GCCallbackFlags,
      *mut (),
    )
  };
}

type RawGCCallback =
  extern "C" fn(*mut Isolate, GCType, GCCallbackFlags, *mut c_void);

impl<F> From<F> for GCCallback
where
  F: UnitType + FnOnce(&mut Isolate, GCType, GCCallbackFlags, *mut ()),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoGCCallback>(
      isolate: *mut Isolate,
      r#type: GCType,
      flags: GCCallbackFlags,
      data: *mut c_void,
    ) {
      let isolate = unsafe { &mut *isolate };
      let data = data as *mut ();
      (F::get())(isolate, r#type, flags, data)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_gc_callback(
  _isolate: &mut Isolate,
  _type: GCType,
  _flags: GCCallbackFlags,
  _data: *mut (),
) {
  unimplemented!()
}

#[test]
fn gc_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGCCallback>(_: F) -> GCCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_gc_callback);
}

#[test]
fn gc_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(f: impl Into<GCCallback>) -> GCCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_gc_callback);
}

#[test]
fn gc_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(f: impl_into_gc_callback!()) -> GCCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_gc_callback);
  let _ =
    pass_as_impl_into_macro(|_isolate, _type, _flags, _data| unimplemented!());
}

/// Embedder callback for `Atomics.wait()` that can be added through
/// `SetAtomicsWaitCallback`.
///
/// This will be called just before starting to wait with the `event` value
/// `kStartWait` and after finishing waiting with one of the other
/// values of `AtomicsWaitEvent` inside of an `Atomics.wait()` call.
///
/// `array_buffer` will refer to the underlying SharedArrayBuffer,
/// `offset_in_bytes` to the location of the waited-on memory address inside
/// the SharedArrayBuffer.
///
/// `value` and `timeout_in_ms` will be the values passed to
/// the `Atomics.wait()` call. If no timeout was used, `timeout_in_ms`
/// will be `INFINITY`.
///
/// In the `kStartWait` callback, `stop_handle` will be an object that
/// is only valid until the corresponding finishing callback and that
/// can be used to stop the wait process while it is happening.
///
/// This callback may schedule exceptions, *unless* `event` is equal to
/// `kTerminatedExecution`.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn atomics_wait_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
///   event: v8::AtomicsWaitEvent,
///   array_buffer: v8::Local<'s, v8::SharedArrayBuffer>,
///   offset_in_bytes: usize,
///   value: i64,
///   timeout_in_ms: f64,
///   stop_handle: &mut v8::AtomicsWaitWakeHandle,
///   data: *mut (),
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AtomicsWaitCallback(RawAtomicsWaitCallback);

pub trait IntoAtomicsWaitCallback:
  UnitType
  + Into<AtomicsWaitCallback>
  + for<'s> FnOnce(
    &mut HandleScope<'s>,
    AtomicsWaitEvent,
    Local<'s, SharedArrayBuffer>,
    usize,
    i64,
    f64,
    &mut AtomicsWaitWakeHandle,
    *mut (),
  )
{
}

impl<F> IntoAtomicsWaitCallback for F where
  F: UnitType
    + Into<AtomicsWaitCallback>
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      AtomicsWaitEvent,
      Local<'s, SharedArrayBuffer>,
      usize,
      i64,
      f64,
      &mut AtomicsWaitWakeHandle,
      *mut (),
    )
{
}

#[macro_export]
macro_rules! impl_into_atomics_wait_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AtomicsWaitCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
      $crate::AtomicsWaitEvent,
      $crate::Local<'__s, $crate::SharedArrayBuffer>,
      usize,
      i64,
      f64,
      &mut $crate::AtomicsWaitWakeHandle,
      *mut (),
    )
  };
}

type RawAtomicsWaitCallback = for<'s> extern "C" fn(
  AtomicsWaitEvent,
  Local<'s, SharedArrayBuffer>,
  usize,
  i64,
  c_double,
  *mut AtomicsWaitWakeHandle,
  *mut c_void,
);

impl<F> From<F> for AtomicsWaitCallback
where
  F: UnitType
    + for<'s> FnOnce(
      &mut HandleScope<'s>,
      AtomicsWaitEvent,
      Local<'s, SharedArrayBuffer>,
      usize,
      i64,
      f64,
      &mut AtomicsWaitWakeHandle,
      *mut (),
    ),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAtomicsWaitCallback>(
      event: AtomicsWaitEvent,
      array_buffer: Local<'s, SharedArrayBuffer>,
      offset_in_bytes: usize,
      value: i64,
      timeout_in_ms: c_double,
      stop_handle: *mut AtomicsWaitWakeHandle,
      data: *mut c_void,
    ) {
      let scope = &mut unsafe { CallbackScope::new(array_buffer) };
      let stop_handle = unsafe { &mut *stop_handle };
      let data = data as *mut ();
      (F::get())(
        scope,
        event,
        array_buffer,
        offset_in_bytes,
        value,
        timeout_in_ms,
        stop_handle,
        data,
      )
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_atomics_wait_callback<'s>(
  _scope: &mut HandleScope<'s>,
  _event: AtomicsWaitEvent,
  _array_buffer: Local<'s, SharedArrayBuffer>,
  _offset_in_bytes: usize,
  _value: i64,
  _timeout_in_ms: f64,
  _stop_handle: &mut AtomicsWaitWakeHandle,
  _data: *mut (),
) {
  unimplemented!()
}

#[test]
fn atomics_wait_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAtomicsWaitCallback>(
    _: F,
  ) -> AtomicsWaitCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_atomics_wait_callback);
}

#[test]
fn atomics_wait_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AtomicsWaitCallback>,
  ) -> AtomicsWaitCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_atomics_wait_callback);
}

#[test]
fn atomics_wait_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_atomics_wait_callback!(),
  ) -> AtomicsWaitCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_atomics_wait_callback);
  let _ = pass_as_impl_into_macro(
    |_scope,
     _event,
     _array_buffer,
     _offset_in_bytes,
     _value,
     _timeout_in_ms,
     _stop_handle,
     _data| unimplemented!(),
  );
}

// === GetExternallyAllocatedMemoryInBytesCallback ===

/// ## Example
///
/// ```
/// fn get_externally_allocated_memory_in_bytes_callback_example() -> usize {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct GetExternallyAllocatedMemoryInBytesCallback(
  RawGetExternallyAllocatedMemoryInBytesCallback,
);

pub trait IntoGetExternallyAllocatedMemoryInBytesCallback:
  UnitType + Into<GetExternallyAllocatedMemoryInBytesCallback> + FnOnce() -> usize
{
}

impl<F> IntoGetExternallyAllocatedMemoryInBytesCallback for F where
  F: UnitType
    + Into<GetExternallyAllocatedMemoryInBytesCallback>
    + FnOnce() -> usize
{
}

#[macro_export]
macro_rules! impl_into_get_externally_allocated_memory_in_bytes_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::GetExternallyAllocatedMemoryInBytesCallback>
    + ::std::ops::FnOnce(
    ) -> usize
  };
}

type RawGetExternallyAllocatedMemoryInBytesCallback = extern "C" fn() -> usize;

impl<F> From<F> for GetExternallyAllocatedMemoryInBytesCallback
where
  F: UnitType + FnOnce() -> usize,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<
      F: IntoGetExternallyAllocatedMemoryInBytesCallback,
    >() -> usize {
      (F::get())()
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_get_externally_allocated_memory_in_bytes_callback() -> usize {
  unimplemented!()
}

#[test]
fn get_externally_allocated_memory_in_bytes_callback_as_type_param() {
  fn pass_as_type_param<F: IntoGetExternallyAllocatedMemoryInBytesCallback>(
    _: F,
  ) -> GetExternallyAllocatedMemoryInBytesCallback {
    F::get().into()
  }
  let _ =
    pass_as_type_param(mock_get_externally_allocated_memory_in_bytes_callback);
}

#[test]
fn get_externally_allocated_memory_in_bytes_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<GetExternallyAllocatedMemoryInBytesCallback>,
  ) -> GetExternallyAllocatedMemoryInBytesCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(
    mock_get_externally_allocated_memory_in_bytes_callback,
  );
}

#[test]
fn get_externally_allocated_memory_in_bytes_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_get_externally_allocated_memory_in_bytes_callback!(),
  ) -> GetExternallyAllocatedMemoryInBytesCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(
    mock_get_externally_allocated_memory_in_bytes_callback,
  );
  let _ = pass_as_impl_into_macro(|| unimplemented!());
}

/// EntropySource is used as a callback function when v8 needs a source
/// of entropy.
///
/// ## Example
///
/// ```
/// fn entropy_source_example(buffer: &mut [u8]) -> bool {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct EntropySource(RawEntropySource);

pub trait IntoEntropySource:
  UnitType + Into<EntropySource> + FnOnce(&mut [u8]) -> bool
{
}

impl<F> IntoEntropySource for F where
  F: UnitType + Into<EntropySource> + FnOnce(&mut [u8]) -> bool
{
}

#[macro_export]
macro_rules! impl_into_entropy_source {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::EntropySource>
    + ::std::ops::FnOnce(
      &mut [u8],
    ) -> bool
  };
}

type RawEntropySource = extern "C" fn(*mut c_uchar, usize) -> bool;

impl<F> From<F> for EntropySource
where
  F: UnitType + FnOnce(&mut [u8]) -> bool,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoEntropySource>(
      buffer: *mut c_uchar,
      length: usize,
    ) -> bool {
      let buffer = unsafe { slice::from_raw_parts_mut(buffer, length) };
      (F::get())(buffer)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_entropy_source(_buffer: &mut [u8]) -> bool {
  unimplemented!()
}

#[test]
fn entropy_source_as_type_param() {
  fn pass_as_type_param<F: IntoEntropySource>(_: F) -> EntropySource {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_entropy_source);
}

#[test]
fn entropy_source_as_impl_into_trait() {
  fn pass_as_impl_into_trait(f: impl Into<EntropySource>) -> EntropySource {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_entropy_source);
}

#[test]
fn entropy_source_as_impl_into_macro() {
  fn pass_as_impl_into_macro(f: impl_into_entropy_source!()) -> EntropySource {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_entropy_source);
  let _ = pass_as_impl_into_macro(|_buffer| unimplemented!());
}

/// ReturnAddressLocationResolver is used as a callback function when v8 is
/// resolving the location of a return address on the stack. Profilers that
/// change the return address on the stack can use this to resolve the stack
/// location to wherever the profiler stashed the original return address.
///
/// \param return_addr_location A location on stack where a machine
///    return address resides.
/// \returns Either return_addr_location, or else a pointer to the profiler's
///    copy of the original return address.
///
/// \note The resolver function must not cause garbage collection.
///
/// ## Example
///
/// ```
/// fn return_address_location_resolver_example(
///   return_addr_location: usize,
/// ) -> usize {
///   todo!()
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct ReturnAddressLocationResolver(RawReturnAddressLocationResolver);

pub trait IntoReturnAddressLocationResolver:
  UnitType + Into<ReturnAddressLocationResolver> + FnOnce(usize) -> usize
{
}

impl<F> IntoReturnAddressLocationResolver for F where
  F: UnitType + Into<ReturnAddressLocationResolver> + FnOnce(usize) -> usize
{
}

#[macro_export]
macro_rules! impl_into_return_address_location_resolver {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::ReturnAddressLocationResolver>
    + ::std::ops::FnOnce(
      usize,
    ) -> usize
  };
}

type RawReturnAddressLocationResolver = extern "C" fn(usize) -> usize;

impl<F> From<F> for ReturnAddressLocationResolver
where
  F: UnitType + FnOnce(usize) -> usize,
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<F: IntoReturnAddressLocationResolver>(
      return_addr_location: usize,
    ) -> usize {
      (F::get())(return_addr_location)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_return_address_location_resolver(
  _return_addr_location: usize,
) -> usize {
  unimplemented!()
}

#[test]
fn return_address_location_resolver_as_type_param() {
  fn pass_as_type_param<F: IntoReturnAddressLocationResolver>(
    _: F,
  ) -> ReturnAddressLocationResolver {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_return_address_location_resolver);
}

#[test]
fn return_address_location_resolver_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<ReturnAddressLocationResolver>,
  ) -> ReturnAddressLocationResolver {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_return_address_location_resolver);
}

#[test]
fn return_address_location_resolver_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_return_address_location_resolver!(),
  ) -> ReturnAddressLocationResolver {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_return_address_location_resolver);
  let _ = pass_as_impl_into_macro(|_return_addr_location| unimplemented!());
}

/// If callback is set, abort any attempt to execute JavaScript in this
/// context, call the specified callback, and throw an exception.
/// To unset abort, pass nullptr as callback.
///
/// ## Example
///
/// ```
/// # use rusty_v8 as v8;
/// #
/// fn abort_script_execution_callback_example<'s>(
///   scope: &mut v8::HandleScope<'s>,
/// ) {
///   todo!();
/// }
/// ```
#[derive(Copy, Clone)]
#[repr(transparent)]
pub struct AbortScriptExecutionCallback(RawAbortScriptExecutionCallback);

pub trait IntoAbortScriptExecutionCallback:
  UnitType
  + Into<AbortScriptExecutionCallback>
  + for<'s> FnOnce(&mut HandleScope<'s>)
{
}

impl<F> IntoAbortScriptExecutionCallback for F where
  F: UnitType
    + Into<AbortScriptExecutionCallback>
    + for<'s> FnOnce(&mut HandleScope<'s>)
{
}

#[macro_export]
macro_rules! impl_into_abort_script_execution_callback {
  () => {
    impl $crate::support::UnitType
    + ::std::convert::Into<$crate::AbortScriptExecutionCallback>
    + for<'__s> ::std::ops::FnOnce(
      &mut $crate::HandleScope<'__s>,
    )
  };
}

type RawAbortScriptExecutionCallback =
  for<'s> extern "C" fn(*mut Isolate, Local<'s, Context>);

impl<F> From<F> for AbortScriptExecutionCallback
where
  F: UnitType + for<'s> FnOnce(&mut HandleScope<'s>),
{
  fn from(_: F) -> Self {
    #[inline(always)]
    extern "C" fn adapter<'s, F: IntoAbortScriptExecutionCallback>(
      _isolate: *mut Isolate,
      context: Local<'s, Context>,
    ) {
      let scope = &mut unsafe { CallbackScope::new(context) };
      (F::get())(scope)
    }

    Self(adapter::<F>)
  }
}

#[cfg(test)]
fn mock_abort_script_execution_callback<'s>(_scope: &mut HandleScope<'s>) {
  unimplemented!()
}

#[test]
fn abort_script_execution_callback_as_type_param() {
  fn pass_as_type_param<F: IntoAbortScriptExecutionCallback>(
    _: F,
  ) -> AbortScriptExecutionCallback {
    F::get().into()
  }
  let _ = pass_as_type_param(mock_abort_script_execution_callback);
}

#[test]
fn abort_script_execution_callback_as_impl_into_trait() {
  fn pass_as_impl_into_trait(
    f: impl Into<AbortScriptExecutionCallback>,
  ) -> AbortScriptExecutionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_trait(mock_abort_script_execution_callback);
}

#[test]
fn abort_script_execution_callback_as_impl_into_macro() {
  fn pass_as_impl_into_macro(
    f: impl_into_abort_script_execution_callback!(),
  ) -> AbortScriptExecutionCallback {
    f.into()
  }
  let _ = pass_as_impl_into_macro(mock_abort_script_execution_callback);
  let _ = pass_as_impl_into_macro(|_scope| unimplemented!());
}