use std::ffi::c_void;
use std::marker::PhantomData;
use std::mem::{align_of, size_of};
use std::ops::BitOr;
use std::panic::{AssertUnwindSafe, catch_unwind};
use super::NativeFunction;
use crate::function_internal::AsPackedCallable;
use crate::object::{
Object, ObjectArc, ObjectCore, ObjectRef, ObjectRefCore, lock_type_registration,
};
use crate::tvm_ffi_sys::{
TVMFFIAny, TVMFFIByteArray, TVMFFIFieldFlagBitMask, TVMFFIFieldInfo, TVMFFIFieldSetter,
TVMFFIGetTypeInfo, TVMFFIMethodInfo, TVMFFIObject, TVMFFIObjectCreator, TVMFFIObjectHandle,
TVMFFISEqHashKind, TVMFFITypeIndex, TVMFFITypeMetadata, TVMFFITypeRegisterAttr,
TVMFFITypeRegisterField, TVMFFITypeRegisterMetadata, TVMFFITypeRegisterMethod,
};
use crate::type_traits::{AnyCompatible, type_schema_metadata};
use crate::{Any, Error, Function, INTERNAL_ERROR, Result, TYPE_ERROR, VALUE_ERROR};
pub trait ShallowCopy {
fn shallow_copy(&self) -> Self;
}
impl ShallowCopy for Object {
fn shallow_copy(&self) -> Self {
Object::new()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum SEqHashKind {
Unsupported,
TreeNode,
FreeVar,
DAGNode,
ConstTreeNode,
UniqueInstance,
}
impl SEqHashKind {
fn raw(self) -> i32 {
let kind = match self {
SEqHashKind::Unsupported => TVMFFISEqHashKind::kTVMFFISEqHashKindUnsupported,
SEqHashKind::TreeNode => TVMFFISEqHashKind::kTVMFFISEqHashKindTreeNode,
SEqHashKind::FreeVar => TVMFFISEqHashKind::kTVMFFISEqHashKindFreeVar,
SEqHashKind::DAGNode => TVMFFISEqHashKind::kTVMFFISEqHashKindDAGNode,
SEqHashKind::ConstTreeNode => TVMFFISEqHashKind::kTVMFFISEqHashKindConstTreeNode,
SEqHashKind::UniqueInstance => TVMFFISEqHashKind::kTVMFFISEqHashKindUniqueInstance,
};
kind as i32
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FieldFlags(i64);
impl FieldFlags {
pub const NONE: Self = Self(0);
pub const WRITABLE: Self = Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskWritable);
pub const SEQ_HASH_IGNORE: Self =
Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskSEqHashIgnore);
pub const SEQ_HASH_DEF_PATTERN: Self =
Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskSEqHashDefPattern);
pub const SEQ_HASH_DEF_SIMPLE: Self =
Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskSEqHashDefSimple);
pub const REPR_OFF: Self = Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskReprOff);
pub const COMPARE_OFF: Self =
Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskCompareOff);
pub const HASH_OFF: Self = Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskHashOff);
pub const INIT_OFF: Self = Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskInitOff);
pub const KW_ONLY: Self = Self::of(TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskKwOnly);
const fn of(bit: TVMFFIFieldFlagBitMask) -> Self {
Self(bit as i64)
}
pub fn bits(self) -> i64 {
self.0
}
}
impl BitOr for FieldFlags {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
pub struct ObjectDef<N: ObjectCore> {
type_index: i32,
fresh: bool,
creator: Option<TVMFFIObjectCreator>,
error: Option<Error>,
method_names: Vec<String>,
_object: PhantomData<N>,
}
impl<N: ObjectCore> ObjectDef<N> {
unsafe fn registering(
type_index: i32,
kind: Option<SEqHashKind>,
creator: Option<TVMFFIObjectCreator>,
) -> Result<Self> {
let info = unsafe { TVMFFIGetTypeInfo(type_index) };
crate::ensure!(
!info.is_null(),
INTERNAL_ERROR,
"no type info for `{}` (type index {type_index})",
N::TYPE_KEY
);
let fresh = unsafe { (*info).metadata.is_null() };
crate::ensure!(
fresh
|| super::TypeAttrColumn::lookup("__ffi_type_final__")
.and_then(|column| column.get_raw_ffi_any(type_index))
.is_some_and(|cell| cell.type_index != TVMFFITypeIndex::kTVMFFINone as i32),
INTERNAL_ERROR,
"`{}` has reflection metadata but no `__ffi_type_final__`: an earlier registration \
of it failed, or another language registered the key without it",
N::TYPE_KEY
);
if fresh {
let kind = match kind {
Some(kind) => kind.raw(),
None => unsafe { inherited_kind(info) },
};
let metadata = unsafe {
TVMFFITypeMetadata {
doc: TVMFFIByteArray::from_str(""),
creator,
total_size: size_of::<N>() as i32,
structural_eq_hash_kind: kind,
}
};
unsafe { crate::check_safe_call!(TVMFFITypeRegisterMetadata(type_index, &metadata))? };
}
Ok(Self {
type_index,
fresh,
creator,
error: None,
method_names: Vec::new(),
_object: PhantomData,
})
}
#[doc(hidden)]
pub unsafe fn field<F: AnyCompatible>(
self,
name: &str,
doc: &str,
offset: usize,
flags: FieldFlags,
) -> Result<Self> {
if !self.fresh {
return Ok(self);
}
if self.creator.is_some() && flags.bits() & FieldFlags::INIT_OFF.bits() != 0 {
let zero = std::mem::MaybeUninit::<F>::zeroed();
crate::ensure!(
!unsafe { F::is_undefined(zero.as_ptr()) },
VALUE_ERROR,
"`init_off` field `{name}` of `{}` stays all-zero after `__ffi_init__`, which \
is no value of `{}`",
N::TYPE_KEY,
F::type_str()
);
}
let type_str = F::type_str();
crate::ensure!(
F::has_field_layout(),
TYPE_ERROR,
"field `{name}` of `{}`: `Option` of a non-object value (`{type_str}`) has no FFI \
field layout; use `tvm_ffi::Optional<T>`",
N::TYPE_KEY
);
let metadata = type_schema_metadata(&F::type_schema());
let info = TVMFFIFieldInfo {
name: unsafe { TVMFFIByteArray::from_str(name) },
doc: unsafe { TVMFFIByteArray::from_str(doc) },
metadata: unsafe { TVMFFIByteArray::from_str(&metadata) },
flags: flags.bits(),
size: size_of::<F>() as i64,
alignment: align_of::<F>() as i64,
offset: offset as i64,
getter: Some(field_getter::<F>),
setter: field_setter::<F> as TVMFFIFieldSetter as *mut c_void,
default_value_or_factory: TVMFFIAny::new(),
field_static_type_index: field_static_type_index(&type_str),
};
crate::check_safe_call!(unsafe { TVMFFITypeRegisterField(self.type_index, &info) })?;
Ok(self)
}
fn shallow_copy(self) -> Result<Self>
where
N: ShallowCopy,
{
if !self.fresh {
return Ok(self);
}
let shallow_copy = Function::from_typed(|object: ObjectRef| shallow_copy_any::<N>(&object));
register_type_attr(
self.type_index,
"__ffi_shallow_copy__",
Any::from(shallow_copy),
)?;
Ok(self)
}
pub fn def<F, I, O>(&mut self, name: &str, func: F, doc: &str) -> &mut Self
where
F: AsPackedCallable<I, O> + Send + Sync + 'static,
{
self.method(name, func, doc, false)
}
pub fn def_static<F, I, O>(&mut self, name: &str, func: F, doc: &str) -> &mut Self
where
F: AsPackedCallable<I, O> + Send + Sync + 'static,
{
self.method(name, func, doc, true)
}
fn method<F, I, O>(&mut self, name: &str, func: F, doc: &str, is_static: bool) -> &mut Self
where
F: AsPackedCallable<I, O> + Send + Sync + 'static,
{
if !self.fresh || self.error.is_some() {
return self;
}
if self.method_names.iter().any(|n| n == name) {
self.error = Some(Error::new(
VALUE_ERROR,
&format!("duplicate method `{name}` of `{}`", N::TYPE_KEY),
));
return self;
}
self.method_names.push(name.to_string());
let metadata = type_schema_metadata(&F::type_schema());
let func = Function::from_typed(func);
let flags = if is_static {
TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskIsStaticMethod as i64
} else {
0
};
let mut method = TVMFFIAny::new();
let registered = unsafe {
<Function as AnyCompatible>::copy_to_any_view(&func, &mut method);
let info = TVMFFIMethodInfo {
name: TVMFFIByteArray::from_str(name),
doc: TVMFFIByteArray::from_str(doc),
metadata: TVMFFIByteArray::from_str(&metadata),
flags,
method,
};
crate::check_safe_call!(TVMFFITypeRegisterMethod(self.type_index, &info))
};
let registered = registered.and_then(|()| {
if is_static && name == "__ffi_init__" {
register_type_attr(self.type_index, name, Any::from(func))
} else {
Ok(())
}
});
if let Err(error) = registered {
self.error = Some(Error::new(
error.kind(),
&format!("registering method `{name}`: {}", error.message()),
));
}
self
}
fn finish(self) -> Result<()> {
if let Some(error) = self.error {
return Err(error);
}
if !self.fresh {
return Ok(());
}
if let Some(creator) = self.creator {
let new = Function::from_typed(move || -> Result<ObjectRef> {
let mut handle: TVMFFIObjectHandle = std::ptr::null_mut();
crate::check_safe_call!(unsafe { creator(&mut handle) })?;
Ok(unsafe { ObjectRef::from_data(ObjectArc::from_raw(handle.cast::<Object>())) })
});
register_type_attr(self.type_index, "__ffi_new__", Any::from(new))?;
let explicit_init = self.method_names.iter().any(|name| name == "__ffi_init__");
if !explicit_init
&& let Ok(register_init) = Function::get_global("ffi._RegisterFFIInit")
{
register_init.call_tuple((self.type_index,))?;
}
}
register_type_attr(
self.type_index,
"__ffi_type_final__",
Any::from(N::TYPE_FINAL),
)
}
}
#[doc(hidden)]
pub unsafe fn register_object<N: ObjectCore + ShallowCopy>(
type_index: i32,
kind: Option<SEqHashKind>,
creator: Option<TVMFFIObjectCreator>,
fields: impl FnOnce(ObjectDef<N>) -> Result<ObjectDef<N>>,
methods: impl FnOnce(&mut ObjectDef<N>),
) -> Result<()> {
let mut def =
unsafe { fields(ObjectDef::registering(type_index, kind, creator)?)?.shallow_copy()? };
methods(&mut def);
def.finish()
}
pub struct TypeAttrDef<T: ObjectCore> {
_type: PhantomData<fn() -> T>,
}
impl<T: ObjectCore> TypeAttrDef<T> {
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Self { _type: PhantomData }
}
pub fn set_attr(self, name: &str, value: impl Into<Any> + Send + Sync) -> Result<Self> {
let value = value.into();
ensure_not_opaque_ptr(name, &value)?;
self.register(name, value)
}
pub unsafe fn set_native_fn_attr<Args, R>(
self,
name: &str,
f: NativeFunction<Args, R>,
) -> Result<Self> {
self.register(name, unsafe { f.into_any() })
}
fn register(self, name: &str, value: Any) -> Result<Self> {
let type_index = T::type_index();
let _registering = lock_type_registration();
register_type_attr(type_index, name, value)?;
Ok(self)
}
}
pub(super) fn ensure_not_opaque_ptr(name: &str, value: &Any) -> Result<()> {
crate::ensure!(
value.type_index() != TVMFFITypeIndex::kTVMFFIOpaquePtr as i32,
TYPE_ERROR,
"attribute `{name}` cannot be an opaque pointer; register a native hook through \
`NativeFunction`"
);
Ok(())
}
unsafe fn inherited_kind(info: *const crate::tvm_ffi_sys::TVMFFITypeInfo) -> i32 {
for depth in unsafe { (0..(*info).type_depth).rev() } {
let ancestor = unsafe { *(*info).type_acenstors.add(depth as usize) };
if !ancestor.is_null() && unsafe { !(*ancestor).metadata.is_null() } {
return unsafe { (*(*ancestor).metadata).structural_eq_hash_kind };
}
}
SEqHashKind::Unsupported.raw()
}
fn shallow_copy_any<N: ObjectCore + ShallowCopy>(object: &ObjectRef) -> Result<Any> {
let Some(node) = object.downcast_ref::<N>() else {
return Err(Error::new(
TYPE_ERROR,
&format!(
"__ffi_shallow_copy__ of `{}` applied to a `{}`",
N::TYPE_KEY,
object_type_key(object)
),
));
};
let copy = ObjectArc::new(node.shallow_copy());
let copy =
unsafe { ObjectRef::from_data(ObjectArc::from_raw(ObjectArc::into_raw(copy).cast())) };
Ok(Any::from(copy))
}
fn object_type_key(object: &ObjectRef) -> String {
let type_index =
unsafe { (*ObjectArc::as_ptr(ObjectRef::data(object)).cast::<TVMFFIObject>()).type_index };
let info = unsafe { TVMFFIGetTypeInfo(type_index) };
if info.is_null() {
return format!("type index {type_index}");
}
unsafe { (*info).type_key.as_str().to_string() }
}
pub(super) fn register_type_attr(type_index: i32, name: &str, mut value: Any) -> Result<()> {
let name = unsafe { TVMFFIByteArray::from_str(name) };
let value = Any::as_raw_ffi_any_mut(&mut value);
crate::check_safe_call!(unsafe { TVMFFITypeRegisterAttr(type_index, &name, value) })
}
unsafe extern "C" fn field_getter<F: AnyCompatible>(
field: *mut c_void,
result: *mut TVMFFIAny,
) -> i32 {
let read = catch_unwind(AssertUnwindSafe(|| {
let field = field.cast::<F>();
let value = if unsafe { F::is_undefined(field) } {
Any::new()
} else {
unsafe { (*field).to_any() }
};
unsafe { std::ptr::write(result, Any::into_raw_ffi_any(value)) };
}));
match read {
Ok(()) => 0,
Err(_) => {
let message = format!("panic while reading a field of type {}", F::type_str());
Error::set_raised(&Error::new(INTERNAL_ERROR, &message));
-1
}
}
}
unsafe extern "C" fn field_setter<F: AnyCompatible>(
field: *mut c_void,
value: *const TVMFFIAny,
) -> i32 {
let written = catch_unwind(AssertUnwindSafe(|| {
match unsafe { F::try_cast_from_any_view(&*value) } {
Ok(converted) => {
let field = field.cast::<F>();
if unsafe { F::is_undefined(field) } {
unsafe { field.write(converted) };
} else {
unsafe { *field = converted };
}
None
}
Err(()) => Some(unsafe {
Error::new(
TYPE_ERROR,
&format!(
"expected a field value of type {}, got {}",
F::type_str(),
F::get_mismatch_type_info(&*value)
),
)
}),
}
}));
let error = match written {
Ok(None) => return 0,
Ok(Some(error)) => error,
Err(_) => Error::new(
INTERNAL_ERROR,
&format!("panic while writing a field of type {}", F::type_str()),
),
};
Error::set_raised(&error);
-1
}
pub(crate) fn field_static_type_index(type_str: &str) -> i32 {
use TVMFFITypeIndex::*;
const ANY: i32 = -1;
let origin = type_str.split('<').next().unwrap_or(type_str).trim();
match origin {
"None" => kTVMFFINone as i32,
"int" => kTVMFFIInt as i32,
"bool" => kTVMFFIBool as i32,
"float" => kTVMFFIFloat as i32,
"void*" => kTVMFFIOpaquePtr as i32,
"DataType" => kTVMFFIDataType as i32,
"Device" => kTVMFFIDevice as i32,
"DLTensor*" => kTVMFFIDLTensorPtr as i32,
"ffi.String" | "ffi.Bytes" | "BigInt" | "Optional" => ANY,
"ffi.Function" => kTVMFFIFunction as i32,
"ffi.Shape" => kTVMFFIShape as i32,
"Array" => kTVMFFIArray as i32,
"List" => kTVMFFIList as i32,
_ => kTVMFFIStaticObjectBegin as i32,
}
}
#[cfg(test)]
mod tests {
use super::field_static_type_index;
use crate::type_traits::{AnyCompatible, type_schema_metadata};
use crate::{Array, List, Map};
#[test]
fn field_static_type_indices_follow_the_cpp_type_traits() {
assert_eq!(field_static_type_index("int"), 1);
assert_eq!(field_static_type_index("ffi.String"), -1);
assert_eq!(field_static_type_index("Optional<my.Node>"), -1);
assert_eq!(field_static_type_index("my.Node"), 64);
assert_eq!(field_static_type_index("Array<my.Node>"), 71);
assert_eq!(field_static_type_index("List<int>"), 75);
assert_eq!(field_static_type_index("Map<ffi.String, int>"), 64);
}
#[test]
fn field_schemas_follow_the_cpp_type_traits() {
assert_eq!(
<Map<crate::String, i64>>::type_schema(),
r#"{"type":"ffi.Map","args":[{"type":"ffi.String"},{"type":"int"}]}"#
);
assert_eq!(
<List<i64>>::type_schema(),
r#"{"type":"ffi.List","args":[{"type":"int"}]}"#
);
assert_eq!(
<Option<Array<crate::String>>>::type_schema(),
r#"{"type":"Optional","args":[{"type":"ffi.Array","args":[{"type":"ffi.String"}]}]}"#
);
assert_eq!(
type_schema_metadata(r#"{"type":"int"}"#),
r#"{"type_schema":"{\"type\":\"int\"}"}"#
);
assert_eq!(
type_schema_metadata("a/b\u{8}\u{7f}"),
r#"{"type_schema":"a\/b\b\u007f"}"#
);
}
}