#[doc(hidden)]
pub use paste;
#[doc(hidden)]
#[macro_export]
macro_rules! function_name {
() => {{
fn f() {}
fn type_name_of<T>(_: T) -> &'static str {
::core::any::type_name::<T>()
}
let name = type_name_of(f);
&name[..name.len() - 3]
}};
}
#[macro_export]
macro_rules! cached_global_func {
($name:literal) => {{
static FUNC: $crate::extra::cold_init_lazy_lock::ColdInitLazyLock<
$crate::function::Function,
> = $crate::extra::cold_init_lazy_lock::ColdInitLazyLock::new(|| {
$crate::function::Function::get_global($name).unwrap_or_else(|_| {
::core::panic!(::core::concat!(
"global function `",
$name,
"` is not registered"
))
})
});
&*FUNC
}};
}
#[macro_export]
macro_rules! cached_field_getter {
($owner:ty, $name:literal) => {{
static GETTER: $crate::extra::cold_init_lazy_lock::ColdInitLazyLock<
$crate::reflection::FieldGetter<$owner>,
> = $crate::extra::cold_init_lazy_lock::ColdInitLazyLock::new(|| {
$crate::reflection::FieldGetter::of::<$owner>($name).unwrap_or_else(|_| {
::core::panic!(::core::concat!(
"`",
::core::stringify!($owner),
"` has no reflected field `",
$name,
"`"
))
})
});
&*GETTER
}};
}
#[doc(hidden)]
#[macro_export]
macro_rules! check_safe_call {
($expr:expr) => {{
let ret_code = $expr;
if ret_code == 0 {
::core::result::Result::Ok(())
} else {
let error = $crate::error::Error::from_raised();
::core::result::Result::Err(error)
}
}};
}
#[macro_export]
macro_rules! format_err {
($error_kind:expr, $fmt:expr $(, $args:expr)* $(,)?) => {{
let context = ::std::format!(
" File \"{}\", line {}, in {}\n",
::core::file!(),
::core::line!(),
$crate::function_name!()
);
$crate::error::Error::new($error_kind, &::std::format!($fmt $(, $args)*))
.with_backtrace(&context)
}};
}
#[macro_export]
macro_rules! bail {
($error_kind:expr, $fmt:expr $(, $args:expr)* $(,)?) => {{
return ::core::result::Result::Err($crate::format_err!($error_kind, $fmt $(, $args)*));
}};
}
#[macro_export]
macro_rules! ensure {
($cond:expr, $error_kind:expr, $fmt:expr $(, $args:expr)* $(,)?) => {{
if !$cond {
$crate::bail!($error_kind, $fmt $(, $args)*);
}
}};
}
#[macro_export]
macro_rules! attach_context {
($error:expr) => {{
match $error {
::core::result::Result::Ok(value) => ::core::result::Result::Ok(value),
::core::result::Result::Err(error) => {
let context = ::std::format!(
" File \"{}\", line {}, in {}\n",
::core::file!(),
::core::line!(),
$crate::function_name!()
);
::core::result::Result::Err($crate::error::Error::with_appended_backtrace(
error, &context,
))
}
}
}};
}
#[macro_export]
macro_rules! impl_object_ref_upcast {
(unsafe $($source:ty => $target:ty),+ $(,)?) => {
$(
impl ::std::convert::From<$source> for $target {
#[inline]
fn from(value: $source) -> Self {
let data = <$source as $crate::object::ObjectRefCore>::into_data(value);
let data = unsafe {
$crate::object::ObjectArc::from_raw(
$crate::object::ObjectArc::into_raw(data).cast::
<<$target as $crate::object::ObjectRefCore>::ContainerType>(),
)
};
unsafe {
<$target as $crate::object::ObjectRefCore>::from_data(data)
}
}
}
impl ::std::convert::From<&$source> for $target {
#[inline]
fn from(value: &$source) -> Self {
::core::convert::Into::into(::core::clone::Clone::clone(value))
}
}
unsafe impl $crate::type_traits::TypeSubsumes<$source> for $target {}
impl $crate::IntoArg<$target> for $source {
type Output = $target;
#[inline(always)]
fn into_arg(self) -> $target {
::core::convert::Into::into(self)
}
#[inline(always)]
fn into_owned(self) -> $target {
::core::convert::Into::into(self)
}
}
impl<'a> $crate::IntoArg<$target> for &'a $source {
type Output = &'a $target;
#[inline(always)]
fn into_arg(self) -> &'a $target {
::core::convert::AsRef::<$target>::as_ref(self)
}
#[inline(always)]
fn into_owned(self) -> $target {
::core::convert::Into::into(self)
}
}
impl ::core::convert::AsRef<$target> for $source {
#[inline(always)]
fn as_ref(&self) -> &$target {
const _: () = ::core::assert!(
::core::mem::size_of::<$source>() == ::core::mem::size_of::<$target>()
&& ::core::mem::align_of::<$source>()
== ::core::mem::align_of::<$target>(),
"an object reference upcast must keep the reference's layout"
);
unsafe { &*(self as *const $source as *const $target) }
}
}
impl ::core::convert::TryFrom<$target> for $source {
type Error = $crate::error::Error;
#[inline]
fn try_from(value: $target) -> ::core::result::Result<Self, Self::Error> {
$crate::object::ObjectRefCore::downcast::<$source>(value)
.map_err($crate::error::Error::downcast_failed::<$source>)
}
}
impl ::core::convert::TryFrom<&$target> for $source {
type Error = $crate::error::Error;
#[inline]
fn try_from(value: &$target) -> ::core::result::Result<Self, Self::Error> {
match $crate::object::ObjectRefCore::downcast_ref::<$source>(value) {
::core::option::Option::Some(found) => {
::core::result::Result::Ok(::core::clone::Clone::clone(found))
}
::core::option::Option::None => ::core::result::Result::Err(
$crate::error::Error::downcast_failed::<$source>(
::core::clone::Clone::clone(value),
),
),
}
}
}
)+
};
($($source:ty => $target:ty),+ $(,)?) => {
$(
const _: () = {
fn derives_from<T: $crate::object::ObjectDerivesFrom<A, I>, A, I>() {}
fn plain<P: $crate::object::PlainObjectRef>() {}
let _ = derives_from::<
<$source as $crate::object::ObjectRefCore>::ContainerType,
<$target as $crate::object::ObjectRefCore>::ContainerType,
_,
>;
let _ = plain::<$target>;
};
)+
$crate::impl_object_ref_upcast!(unsafe $($source => $target),+);
};
}
#[macro_export]
macro_rules! impl_object_ref_downcast_ref {
(unsafe $($name:ty),+ $(,)?) => {
$(
unsafe impl $crate::type_traits::RefFromAnyUnchecked for $name {
#[inline(always)]
unsafe fn ref_from_any_unchecked(
cell: &$crate::tvm_ffi_sys::TVMFFIAny,
) -> &Self {
const {
::core::assert!(
::core::mem::size_of::<$name>()
== ::core::mem::size_of::<*mut $crate::tvm_ffi_sys::TVMFFIObject>()
&& ::core::mem::align_of::<$name>()
== ::core::mem::align_of::<*mut $crate::tvm_ffi_sys::TVMFFIObject>(),
"a reference downcast target must be exactly one object pointer"
)
};
unsafe { &*(::core::ptr::addr_of!(cell.data_union) as *const Self) }
}
}
unsafe impl $crate::type_traits::DowncastRefFromAny for $name {
#[inline(always)]
unsafe fn downcast_ref_from_any(
cell: &$crate::tvm_ffi_sys::TVMFFIAny,
) -> ::core::option::Option<&Self> {
unsafe { $crate::type_traits::downcast_ref_from_any_in_place::<Self>(cell) }
}
}
unsafe impl $crate::type_traits::DowncastRefFromObject for $name {
#[inline(always)]
unsafe fn downcast_ref_from_object(
place: &*mut $crate::tvm_ffi_sys::TVMFFIObject,
) -> ::core::option::Option<&Self> {
unsafe { $crate::type_traits::downcast_ref_from_object_in_place::<Self>(place) }
}
}
)+
};
}
#[macro_export]
macro_rules! impl_any_compatible_conversions {
($($t:ty),* $(,)?) => {
$crate::impl_try_from_any!($($t),*);
$crate::impl_into_arg!($($t),*);
$crate::impl_into_packed_arg!($($t),*);
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! impl_try_from_any {
($($t:ty),* $(,)?) => {
$(
impl<'a> ::core::convert::TryFrom<$crate::any::AnyView<'a>> for $t {
type Error = $crate::error::Error;
#[inline(always)]
fn try_from(
value: $crate::any::AnyView<'a>
) -> ::core::result::Result<Self, Self::Error> {
type TryFromTemp = $crate::any::TryFromTemp<$t>;
return <TryFromTemp as ::core::convert::TryFrom<_>>::try_from(value).map(TryFromTemp::into_value);
}
}
impl ::core::convert::TryFrom<$crate::any::Any> for $t {
type Error = $crate::error::Error;
#[inline(always)]
fn try_from(
value: $crate::any::Any
) -> ::core::result::Result<Self, Self::Error> {
type TryFromTemp = $crate::any::TryFromTemp<$t>;
return <TryFromTemp as ::core::convert::TryFrom<_>>::try_from(value).map(TryFromTemp::into_value);
}
}
impl<'a> ::core::convert::TryFrom<&'a $crate::any::Any> for $t {
type Error = $crate::error::Error;
#[inline(always)]
fn try_from(
value: &'a $crate::any::Any
) -> ::core::result::Result<Self, Self::Error> {
type TryFromTemp = $crate::any::TryFromTemp<$t>;
return <TryFromTemp as ::core::convert::TryFrom<_>>::try_from(value).map(TryFromTemp::into_value);
}
}
)*
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! impl_into_arg {
($($t:ty),* $(,)?) => {
$($crate::impl_into_arg!(impl[] $t);)*
};
(impl[$($g:tt)*] $t:ty) => {
impl<$($g)*> $crate::IntoArg<$t> for $t {
type Output = $t;
#[inline(always)]
fn into_arg(self) -> $t {
self
}
#[inline(always)]
fn into_owned(self) -> $t {
self
}
}
impl<'a, $($g)*> $crate::IntoArg<$t> for &'a $t {
type Output = &'a $t;
#[inline(always)]
fn into_arg(self) -> &'a $t {
self
}
#[inline(always)]
fn into_owned(self) -> $t {
::core::clone::Clone::clone(self)
}
}
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! impl_try_from_any_for_parametric {
($generic_type:ident<$param:ident>) => {
impl<'a, $param: $crate::type_traits::AnyCompatible>
::core::convert::TryFrom<$crate::any::AnyView<'a>> for $generic_type<$param>
{
type Error = $crate::error::Error;
#[inline(always)]
fn try_from(
value: $crate::any::AnyView<'a>,
) -> ::core::result::Result<Self, Self::Error> {
type TryFromTemp<T> = $crate::any::TryFromTemp<$generic_type<$param>>;
return <TryFromTemp<T> as ::core::convert::TryFrom<_>>::try_from(value)
.map(TryFromTemp::<T>::into_value);
}
}
impl<$param: $crate::type_traits::AnyCompatible> ::core::convert::TryFrom<$crate::any::Any>
for $generic_type<$param>
{
type Error = $crate::error::Error;
#[inline(always)]
fn try_from(value: $crate::any::Any) -> ::core::result::Result<Self, Self::Error> {
type TryFromTemp<T> = $crate::any::TryFromTemp<$generic_type<$param>>;
return <TryFromTemp<T> as ::core::convert::TryFrom<_>>::try_from(value)
.map(TryFromTemp::<T>::into_value);
}
}
impl<'a, $param: $crate::type_traits::AnyCompatible>
::core::convert::TryFrom<&'a $crate::any::Any> for $generic_type<$param>
{
type Error = $crate::error::Error;
#[inline(always)]
fn try_from(value: &'a $crate::any::Any) -> ::core::result::Result<Self, Self::Error> {
type TryFromTemp<T> = $crate::any::TryFromTemp<$generic_type<$param>>;
return <TryFromTemp<T> as ::core::convert::TryFrom<_>>::try_from(value)
.map(TryFromTemp::<T>::into_value);
}
}
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! impl_into_packed_arg {
($($t:ty),* $(,)?) => {
$($crate::impl_into_packed_arg!(impl[] $t);)*
};
(impl[$($g:tt)*] $t:ty) => {
impl<$($g)*> $crate::function_internal::PackedCallArg for $t {
type Holder = $t;
#[inline(always)]
fn into_packed_arg(self) -> $t {
self
}
#[inline(always)]
fn as_packed_arg(holder: &Self::Holder) -> $crate::any::AnyView<'_> {
$crate::any::AnyView::from(holder)
}
}
impl<'a, $($g)*> $crate::function_internal::PackedCallArg for &'a $t {
type Holder = &'a $t;
#[inline(always)]
fn into_packed_arg(self) -> &'a $t {
self
}
#[inline(always)]
fn as_packed_arg(holder: &Self::Holder) -> $crate::any::AnyView<'_> {
$crate::any::AnyView::from(*holder)
}
}
};
}
#[macro_export]
macro_rules! tvm_ffi_dll_export_typed_func {
($name:ident, $func:expr) => {
$crate::macros::paste::paste! {
#[unsafe(no_mangle)]
pub unsafe extern "C" fn [<__tvm_ffi_ $name>](
_handle: *mut ::core::ffi::c_void,
args: *const $crate::tvm_ffi_sys::TVMFFIAny,
num_args: i32,
result: *mut $crate::tvm_ffi_sys::TVMFFIAny,
) -> i32 {
let packed_args = $crate::function_internal::packed_args(args, num_args);
let ret_value = match ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| {
$crate::function_internal::call_packed_callable($func, packed_args)
})) {
::core::result::Result::Ok(ret_value) => ret_value,
::core::result::Result::Err(payload) => ::core::result::Result::Err($crate::error::Error::from_panic(payload)),
};
match ret_value {
::core::result::Result::Ok(value) => {
*result = $crate::any::Any::into_raw_ffi_any(value);
0
}
::core::result::Result::Err(error) => {
$crate::error::Error::set_raised(&error);
-1
}
}
}
}
$crate::__tvm_ffi_dll_export_metadata!($name, $func);
};
}
#[macro_export]
macro_rules! tvm_ffi_dll_export_typed_func_doc {
($name:ident, $doc:expr) => {
$crate::__tvm_ffi_dll_export_doc!($name, $doc);
};
}
#[cfg(feature = "export-metadata")]
#[doc(hidden)]
#[macro_export]
macro_rules! __tvm_ffi_dll_export_metadata {
($name:ident, $func:expr) => {
$crate::macros::paste::paste! {
#[unsafe(no_mangle)]
pub unsafe extern "C" fn [<__tvm_ffi__metadata_ $name>](
_handle: *mut ::core::ffi::c_void,
_args: *const $crate::tvm_ffi_sys::TVMFFIAny,
_num_args: i32,
result: *mut $crate::tvm_ffi_sys::TVMFFIAny,
) -> i32 {
let metadata = match ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| {
$crate::function_internal::exported_metadata(&$func)
})) {
::core::result::Result::Ok(metadata) => metadata,
::core::result::Result::Err(payload) => ::core::result::Result::Err($crate::error::Error::from_panic(payload)),
};
$crate::function_internal::write_exported_str(metadata, result)
}
}
};
}
#[cfg(not(feature = "export-metadata"))]
#[doc(hidden)]
#[macro_export]
macro_rules! __tvm_ffi_dll_export_metadata {
($name:ident, $func:expr) => {};
}
#[cfg(feature = "export-metadata")]
#[doc(hidden)]
#[macro_export]
macro_rules! __tvm_ffi_dll_export_doc {
($name:ident, $doc:expr) => {
$crate::macros::paste::paste! {
#[unsafe(no_mangle)]
pub unsafe extern "C" fn [<__tvm_ffi__doc_ $name>](
_handle: *mut ::core::ffi::c_void,
_args: *const $crate::tvm_ffi_sys::TVMFFIAny,
_num_args: i32,
result: *mut $crate::tvm_ffi_sys::TVMFFIAny,
) -> i32 {
const DOC: &str = $doc;
$crate::function_internal::write_exported_str(::core::result::Result::Ok(::std::string::ToString::to_string(DOC)), result)
}
}
};
}
#[cfg(not(feature = "export-metadata"))]
#[doc(hidden)]
#[macro_export]
macro_rules! __tvm_ffi_dll_export_doc {
($name:ident, $doc:expr) => {
const _: &str = $doc;
};
}
#[macro_export]
macro_rules! into_typed_fn {
($f:expr, Fn() -> $ret_ty:ty) => {{
let _f = $f;
move || -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple(())?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty) -> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0,))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty, $t1:ty) -> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0, a1: $t1| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0, a1))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty, $t1:ty, $t2:ty) -> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0, a1: $t1, a2: $t2| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0, a1, a2))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty, $t1:ty, $t2:ty, $t3:ty) -> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0, a1: $t1, a2: $t2, a3: $t3| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0, a1, a2, a3))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty) -> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0, a1: $t1, a2: $t2, a3: $t3, a4: $t4| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0, a1, a2, a3, a4))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty) -> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0, a1: $t1, a2: $t2, a3: $t3, a4: $t4, a5: $t5| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0, a1, a2, a3, a4, a5))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty)
-> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0, a1: $t1, a2: $t2, a3: $t3, a4: $t4, a5: $t5, a6: $t6| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0, a1, a2, a3, a4, a5, a6))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, Fn($t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty)
-> $ret_ty:ty) => {{
let _f = $f;
move |a0: $t0, a1: $t1, a2: $t2, a3: $t3, a4: $t4, a5: $t5, a6: $t6, a7: $t7| -> $ret_ty {
::core::convert::TryInto::try_into(_f.call_tuple((a0, a1, a2, a3, a4, a5, a6, a7))?)
.map_err(::core::convert::Into::into)
}
}};
($f:expr, $($signature:tt)*) => {
::core::compile_error!(::core::concat!(
"expected `Fn(A, ...) -> R` with 0 to 8 arguments, ",
"as in `into_typed_fn!(func, Fn(i32) -> Result<i32>)`"
))
};
}