use super::structural_visit::DefRegionKind;
use crate::any::Any;
use crate::error::{Error, RUNTIME_ERROR, Result, TYPE_ERROR};
use crate::tvm_ffi_sys::TVMFFIFieldFlagBitMask::{
kTVMFFIFieldFlagBitMaskSEqHashDefPattern, kTVMFFIFieldFlagBitMaskSEqHashDefSimple,
kTVMFFIFieldFlagBitMaskSEqHashIgnore, kTVMFFIFieldFlagBitSetterIsFunctionObj,
};
use crate::tvm_ffi_sys::{
TVMFFIAny, TVMFFIByteArray, TVMFFIFieldInfo, TVMFFISEqHashKind, TVMFFITypeIndex,
TVMFFITypeInfo, TVMFFITypeKeyToIndex,
};
use std::ops::ControlFlow;
#[cold]
#[inline(never)]
pub(super) fn runtime_error(message: &str) -> Error {
Error::new(RUNTIME_ERROR, message)
}
#[cold]
#[inline(never)]
pub(super) fn wrong_dispatcher() -> ! {
panic!("structural traversal view used with a different dispatcher instance")
}
#[cold]
#[inline(never)]
pub(super) fn missing_field_getter_error(operation: &str, name: &str) -> Error {
runtime_error(&format!(
"native {operation}: reflected field `{name}` has no getter"
))
}
#[cold]
#[inline(never)]
pub(super) unsafe fn structural_error_from_raw(raw: TVMFFIAny) -> Error {
let value = unsafe { Any::from_raw_ffi_any(raw) };
match Error::try_from(value) {
Ok(error) | Err(error) => error,
}
}
#[inline(always)]
pub(crate) fn raw_ffi_any_same_as(lhs: TVMFFIAny, rhs: TVMFFIAny) -> bool {
lhs.type_index == rhs.type_index
&& lhs.small_str_len == rhs.small_str_len
&& unsafe { lhs.data_union.v_uint64 == rhs.data_union.v_uint64 }
}
#[inline(always)]
pub(crate) fn result_into_raw_ffi_any(result: Result<Any>) -> TVMFFIAny {
match result {
Ok(value) => Any::into_raw_ffi_any(value),
Err(error) => Any::into_raw_ffi_any(Any::from(error)),
}
}
#[inline(always)]
pub(crate) fn reject_error_value(value: Any) -> Result<Any> {
if value.as_raw_ffi_any().type_index != TVMFFITypeIndex::kTVMFFIError as i32 {
return Ok(value);
}
core::hint::cold_path();
Err(Error::new(
TYPE_ERROR,
"a structural handler returned an Error as a value; return it as Err to fail",
))
}
#[inline(always)]
pub(crate) unsafe fn raw_ffi_any_into_result(raw: TVMFFIAny) -> Result<Any> {
if raw.type_index != TVMFFITypeIndex::kTVMFFIError as i32 {
return Ok(unsafe { Any::from_raw_ffi_any(raw) });
}
core::hint::cold_path();
Err(unsafe { structural_error_from_raw(raw) })
}
pub(super) const FLAG_SEQ_HASH_IGNORE: i64 = kTVMFFIFieldFlagBitMaskSEqHashIgnore as i64;
pub(super) const FLAG_SEQ_HASH_DEF_PATTERN: i64 = kTVMFFIFieldFlagBitMaskSEqHashDefPattern as i64;
pub(super) const FLAG_SEQ_HASH_DEF_SIMPLE: i64 = kTVMFFIFieldFlagBitMaskSEqHashDefSimple as i64;
pub(super) const FLAG_SETTER_IS_FUNCTION: i64 = kTVMFFIFieldFlagBitSetterIsFunctionObj as i64;
#[cold]
pub(super) fn registered_type_index(key: &str) -> i32 {
let mut type_index = 0;
if unsafe { TVMFFITypeKeyToIndex(&TVMFFIByteArray::from_str(key), &mut type_index) } != 0 {
panic!("{key} is not registered: {}", Error::from_raised());
}
type_index
}
#[inline(always)]
pub(super) unsafe fn seq_hash_kind(info: *const TVMFFITypeInfo) -> i32 {
let metadata = unsafe { (*info).metadata };
if metadata.is_null() {
TVMFFISEqHashKind::kTVMFFISEqHashKindUnsupported as i32
} else {
unsafe { (*metadata).structural_eq_hash_kind }
}
}
#[inline(always)]
pub(super) fn field_def_region(field: &TVMFFIFieldInfo, inherited: DefRegionKind) -> DefRegionKind {
if inherited == DefRegionKind::Pattern {
DefRegionKind::Pattern
} else if field.flags & FLAG_SEQ_HASH_DEF_SIMPLE != 0 {
DefRegionKind::Simple
} else if field.flags & FLAG_SEQ_HASH_DEF_PATTERN != 0 {
DefRegionKind::Pattern
} else {
inherited
}
}
#[inline(always)]
pub(super) fn free_var_child_region(
inherited: DefRegionKind,
structural_eq_hash_kind: i32,
) -> DefRegionKind {
if inherited == DefRegionKind::Simple
&& structural_eq_hash_kind == TVMFFISEqHashKind::kTVMFFISEqHashKindFreeVar as i32
{
DefRegionKind::None
} else {
inherited
}
}
pub(super) unsafe fn for_each_field_info<B>(
info: *const TVMFFITypeInfo,
callback: &mut impl FnMut(&'static TVMFFIFieldInfo) -> ControlFlow<B>,
) -> Option<B> {
for depth in unsafe { 1..(*info).type_depth } {
let ancestor = unsafe { *(*info).type_acenstors.offset(depth as isize) };
if let Some(value) = unsafe { visit_field_level(ancestor, callback) } {
return Some(value);
}
}
unsafe { visit_field_level(info, callback) }
}
unsafe fn visit_field_level<B>(
info: *const TVMFFITypeInfo,
callback: &mut impl FnMut(&'static TVMFFIFieldInfo) -> ControlFlow<B>,
) -> Option<B> {
if info.is_null() {
return None;
}
let fields = unsafe {
crate::util::slice_from_nullable_raw_parts((*info).fields, (*info).num_fields as usize)
};
for field in fields {
let field: &'static TVMFFIFieldInfo = unsafe { &*(field as *const TVMFFIFieldInfo) };
if let ControlFlow::Break(value) = callback(field) {
return Some(value);
}
}
None
}