use tvm_ffi::derive::{Object, ObjectRef};
use tvm_ffi::reflection::{FieldFlags, FieldGetter, ObjectDef};
use tvm_ffi::reflection::{NativeFunction, TypeAttrColumn, TypeAttrDef};
use tvm_ffi::*;
use tvm_ffi_sys::{
TVMFFIFieldFlagBitMask, TVMFFIFieldInfo, TVMFFIFieldSetter, TVMFFIGetTypeInfo,
TVMFFIMethodInfo, TVMFFISEqHashKind, TVMFFITypeInfo,
};
#[repr(C)]
#[derive(Object)]
#[object(
type_key = "testing.rust.ReflectedPoint",
register,
s_eq_hash_kind = "TreeNode",
reflection = PointObj::reflect_methods
)]
struct PointObj {
base_: Object,
#[reflect]
x: i64,
#[reflect(writable, doc = "The y coordinate.")]
y: f64,
#[reflect(seq_hash_ignore, repr_off)]
label: tvm_ffi::String,
hits: i64,
}
impl PointObj {
fn reflect_methods(def: &mut ObjectDef<Self>) {
def.def(
"norm1",
|p: Point| -> Result<f64> { Ok(p.data.x.abs() as f64 + p.data.y.abs()) },
"The L1 norm.",
)
.def(
"shifted",
|p: Point, dx: i64| -> Result<Point> {
Ok(point(p.data.x + dx, p.data.y, p.data.label.as_str()))
},
"",
)
.def_static(
"origin",
|| -> Result<Point> { Ok(point(0, 0.0, "origin")) },
"The origin.",
);
}
}
#[repr(C)]
#[derive(ObjectRef, Clone)]
struct Point {
data: ObjectArc<PointObj>,
}
#[repr(C)]
#[derive(Object)]
#[object(type_key = "testing.rust.ReflectedPoint3", register, final)]
struct Point3Obj {
base_: PointObj,
#[reflect]
z: i64,
#[reflect(name = "labels")]
tags: Array<tvm_ffi::String>,
#[reflect]
r#type: Option<Point>,
}
#[repr(C)]
#[derive(ObjectRef, Clone)]
struct Point3 {
data: ObjectArc<Point3Obj>,
}
tvm_ffi::impl_object_ref_upcast!(Point3 => Point);
fn point_obj(x: i64, y: f64, label: &str) -> PointObj {
PointObj {
base_: Object::new(),
x,
y,
label: label.into(),
hits: 7,
}
}
fn point(x: i64, y: f64, label: &str) -> Point {
Point {
data: ObjectArc::new(point_obj(x, y, label)),
}
}
fn point3(x: i64, z: i64) -> Point3 {
Point3 {
data: ObjectArc::new(Point3Obj {
base_: point_obj(x, 0.5, "p3"),
z,
tags: Array::from_vec(vec!["a".into(), "b".into()]),
r#type: Some(point(1, 2.0, "inner")),
}),
}
}
fn type_info<N: ObjectCore>() -> &'static TVMFFITypeInfo {
unsafe { &*TVMFFIGetTypeInfo(N::type_index()) }
}
fn fields(info: &TVMFFITypeInfo) -> &[TVMFFIFieldInfo] {
unsafe { std::slice::from_raw_parts(info.fields, info.num_fields as usize) }
}
fn methods(info: &TVMFFITypeInfo) -> &[TVMFFIMethodInfo] {
if info.num_methods == 0 {
return &[];
}
unsafe { std::slice::from_raw_parts(info.methods, info.num_methods as usize) }
}
fn metadata_of(type_schema: &str) -> std::string::String {
format!(
r#"{{"type_schema":"{}"}}"#,
type_schema.replace('"', "\\\"")
)
}
fn call(name: &str, args: &[AnyView]) -> Any {
Function::get_global(name)
.unwrap()
.call_packed(args)
.unwrap()
}
#[test]
fn test_reflected_fields_are_registered_with_the_type() {
let info = type_info::<PointObj>();
let names: Vec<&str> = fields(info)
.iter()
.map(|f| unsafe { f.name.as_str() })
.collect();
assert_eq!(names, ["x", "y", "label"]);
let [x, y, label] = fields(info) else {
unreachable!()
};
assert_eq!(x.flags, 0);
assert_eq!(x.offset, std::mem::offset_of!(PointObj, x) as i64);
assert_eq!(x.field_static_type_index, TypeIndex::kTVMFFIInt as i32);
assert_eq!(
unsafe { x.metadata.as_str() },
r#"{"type_schema":"{\"type\":\"int\"}"}"#
);
assert_eq!(
y.flags,
TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskWritable as i64
);
assert_eq!(
label.flags,
(FieldFlags::SEQ_HASH_IGNORE | FieldFlags::REPR_OFF).bits()
);
assert_eq!(label.field_static_type_index, -1);
let metadata = unsafe { &*info.metadata };
assert_eq!(
metadata.total_size as usize,
std::mem::size_of::<PointObj>()
);
assert_eq!(
metadata.structural_eq_hash_kind,
TVMFFISEqHashKind::kTVMFFISEqHashKindTreeNode as i32
);
let info = type_info::<Point3Obj>();
let names: Vec<&str> = fields(info)
.iter()
.map(|f| unsafe { f.name.as_str() })
.collect();
assert_eq!(names, ["z", "labels", "type"]);
assert_eq!(
unsafe { fields(info)[1].metadata.as_str() },
r#"{"type_schema":"{\"type\":\"ffi.Array\",\"args\":[{\"type\":\"ffi.String\"}]}"}"#
);
assert_eq!(
unsafe { (*info.metadata).structural_eq_hash_kind },
TVMFFISEqHashKind::kTVMFFISEqHashKindTreeNode as i32
);
}
#[test]
fn test_field_docs_come_from_doc_comments_or_reflect() {
let [x, y, label] = fields(type_info::<PointObj>()) else {
unreachable!()
};
assert_eq!(unsafe { x.doc.as_str() }, "The x coordinate.\n\nSigned.");
assert_eq!(unsafe { y.doc.as_str() }, "The y coordinate.");
assert_eq!(unsafe { label.doc.as_str() }, "");
let labels = &fields(type_info::<Point3Obj>())[1];
assert_eq!(unsafe { labels.name.as_str() }, "labels");
assert_eq!(labels.offset, std::mem::offset_of!(Point3Obj, tags) as i64);
let p3 = point3(1, 2);
let getter = FieldGetter::new(Point3Obj::type_index(), "labels").unwrap();
let tags = getter.get::<_, Array<tvm_ffi::String>>(&*p3.data).unwrap();
assert_eq!(tags.len(), 2);
}
#[test]
fn test_methods_are_registered_with_the_type() {
let info = type_info::<PointObj>();
let names: Vec<&str> = methods(info)
.iter()
.map(|m| unsafe { m.name.as_str() })
.collect();
assert_eq!(names, ["norm1", "shifted", "origin"]);
let [norm1, shifted, origin] = methods(info) else {
unreachable!()
};
assert_eq!(norm1.flags, 0);
assert_eq!(unsafe { norm1.doc.as_str() }, "The L1 norm.");
assert_eq!(unsafe { shifted.doc.as_str() }, "");
assert_eq!(
origin.flags,
TVMFFIFieldFlagBitMask::kTVMFFIFieldFlagBitMaskIsStaticMethod as i64
);
assert_eq!(unsafe { origin.doc.as_str() }, "The origin.");
let point = r#"{"type":"testing.rust.ReflectedPoint"}"#;
assert_eq!(
unsafe { shifted.metadata.as_str() },
metadata_of(&format!(
r#"{{"type":"ffi.Function","named_args":{{"return":[{point}],"params":[{point},{{"type":"int"}}]}}}}"#
))
);
assert_eq!(
unsafe { origin.metadata.as_str() },
metadata_of(&format!(
r#"{{"type":"ffi.Function","named_args":{{"return":[{point}],"params":[]}}}}"#
))
);
assert_eq!(methods(type_info::<Point3Obj>()).len(), 0);
}
#[test]
fn test_methods_are_called_through_the_type_table() {
let norm1 = tvm_ffi::reflection::get_method("testing.rust.ReflectedPoint", "norm1").unwrap();
let norm = f64::try_from(norm1.call_tuple((point(3, -4.5, "p"),)).unwrap()).unwrap();
assert_eq!(norm, 7.5);
let norm = f64::try_from(norm1.call_tuple((point3(2, 9),)).unwrap()).unwrap();
assert_eq!(norm, 2.5);
let shifted =
tvm_ffi::reflection::get_method_by_index(PointObj::type_index(), "shifted").unwrap();
let moved = Point::try_from(shifted.call_tuple((point(3, 1.0, "p"), 4i64)).unwrap()).unwrap();
assert_eq!(
(moved.data.x, moved.data.y, moved.data.label.as_str()),
(7, 1.0, "p")
);
let origin = tvm_ffi::reflection::get_method("testing.rust.ReflectedPoint", "origin").unwrap();
let origin = Point::try_from(origin.call_tuple(()).unwrap()).unwrap();
assert_eq!((origin.data.x, origin.data.label.as_str()), (0, "origin"));
let error = norm1.call_tuple((1i64,)).err().unwrap();
assert_eq!(error.kind(), TYPE_ERROR);
}
#[repr(C)]
#[derive(Object)]
#[object(
type_key = "testing.rust.ReflectedTally",
register,
final,
reflection = Self::reflect_methods
)]
struct TallyObj {
base_: Object,
count: i64,
}
#[repr(C)]
#[derive(ObjectRef, Clone)]
struct Tally {
data: ObjectArc<TallyObj>,
}
impl TallyObj {
fn reflect_methods(def: &mut ObjectDef<Self>) {
def.def("count", |t: Tally| -> Result<i64> { Ok(t.data.count) }, "");
}
}
#[test]
fn test_types_with_only_methods_register_their_reflection() {
let info = type_info::<TallyObj>();
assert_eq!(info.num_fields, 0);
assert!(!info.metadata.is_null());
assert_eq!(methods(info).len(), 1);
assert!(
bool::try_from(
TypeAttrColumn::lookup("__ffi_type_final__")
.and_then(|column| column.get(TallyObj::type_index()))
.unwrap()
)
.unwrap()
);
let count = tvm_ffi::reflection::get_method_by_index(TallyObj::type_index(), "count").unwrap();
let tally = Tally {
data: ObjectArc::new(TallyObj {
base_: Object::new(),
count: 11,
}),
};
assert_eq!(
i64::try_from(count.call_tuple((tally,)).unwrap()).unwrap(),
11
);
}
#[test]
fn test_reflected_fields_read_and_write_through_the_c_abi() {
let p3 = point3(3, 4);
let x = FieldGetter::of::<Point3Obj>("x").unwrap();
assert_eq!(x.get::<i64>(&p3.data).unwrap(), 3);
let z: i64 = tvm_ffi::cached_field_getter!(Point3Obj, "z")
.get(&p3.data)
.unwrap();
assert_eq!(z, 4);
let p = point(1, 2.0, "p");
let y = &fields(type_info::<PointObj>())[1];
let setter: TVMFFIFieldSetter = unsafe { std::mem::transmute(y.setter) };
let field = unsafe {
ObjectArc::as_ptr(&p.data)
.cast::<u8>()
.add(y.offset as usize)
.cast_mut()
};
let value = Any::from(8.5f64);
assert_eq!(
unsafe { setter(field.cast(), &Any::into_raw_ffi_any(value.clone())) },
0
);
assert_eq!(p.data.y, 8.5);
let value = Any::from(tvm_ffi::String::from("no"));
assert_ne!(
unsafe { setter(field.cast(), &Any::into_raw_ffi_any(value.clone())) },
0
);
let error = Error::from_raised();
assert_eq!(error.kind(), TYPE_ERROR);
assert_eq!(p.data.y, 8.5);
}
#[test]
fn test_cpp_structural_equality_and_hash_see_reflected_fields() {
let equal = |a: &Point, b: &Point| -> bool {
let (a, b) = (Any::from(a.clone()), Any::from(b.clone()));
let args = [
AnyView::from(&a),
AnyView::from(&b),
AnyView::from(&false),
AnyView::from(&false),
];
bool::try_from(call("ffi.StructuralEqual", &args)).unwrap()
};
let hash = |a: &Point| -> i64 {
let a = Any::from(a.clone());
let args = [
AnyView::from(&a),
AnyView::from(&false),
AnyView::from(&false),
];
i64::try_from(call("ffi.StructuralHash", &args)).unwrap()
};
assert!(equal(&point(1, 2.0, "a"), &point(1, 2.0, "b")));
assert_eq!(hash(&point(1, 2.0, "a")), hash(&point(1, 2.0, "b")));
assert!(!equal(&point(1, 2.0, "a"), &point(2, 2.0, "a")));
assert!(!equal(&point(1, 2.0, "a"), &point(1, 3.0, "a")));
assert!(equal(&point3(1, 2).into(), &point3(1, 2).into()));
assert!(!equal(&point3(1, 2).into(), &point3(1, 3).into()));
assert!(!equal(&point3(1, 2).into(), &point3(0, 2).into()));
}
#[test]
fn test_repr_and_deep_copy_see_reflected_fields() {
let p = Any::from(point(5, 1.5, "hidden"));
let repr = tvm_ffi::String::try_from(call("ffi.ReprPrint", &[AnyView::from(&p)])).unwrap();
assert!(repr.as_str().contains("x=5"), "{}", repr.as_str());
assert!(!repr.as_str().contains("hidden"), "{}", repr.as_str());
let original = point3(1, 2);
let any = Any::from(original.clone());
let copy = Point3::try_from(call("ffi.DeepCopy", &[AnyView::from(&any)])).unwrap();
assert!(!copy.same_as(&original));
assert_eq!((copy.data.base_.x, copy.data.z), (1, 2));
assert_eq!(copy.data.tags.len(), 2);
let (inner, original_inner) = (
copy.data.r#type.clone().unwrap(),
original.data.r#type.clone().unwrap(),
);
assert!(!inner.same_as(&original_inner));
assert_eq!(inner.data.x, 1);
}
#[test]
fn test_shallow_copy_and_finality_are_type_attributes() {
let original = point(1, 2.0, "p");
let shallow_copy = Function::try_from(
TypeAttrColumn::lookup("__ffi_shallow_copy__")
.and_then(|column| column.get(PointObj::type_index()))
.unwrap(),
)
.unwrap();
let copy = Point::try_from(shallow_copy.call_tuple((original.clone(),)).unwrap()).unwrap();
assert!(!copy.same_as(&original));
assert_eq!(
(
copy.data.x,
copy.data.y,
copy.data.label.as_str(),
copy.data.hits
),
(1, 2.0, "p", 7)
);
let other = Counter {
data: ObjectArc::new(CounterObj {
base_: Object::new(),
count: 0,
}),
};
let error = shallow_copy.call_tuple((other,)).err().unwrap();
assert_eq!(error.kind(), TYPE_ERROR);
let is_final = |type_index| {
bool::try_from(
TypeAttrColumn::lookup("__ffi_type_final__")
.and_then(|column| column.get(type_index))
.unwrap(),
)
.unwrap()
};
assert!(!is_final(PointObj::type_index()));
assert!(is_final(Point3Obj::type_index()));
}
#[repr(C)]
#[derive(Object)]
#[object(type_key = "testing.rust.Unreflected", register, final)]
struct CounterObj {
base_: Object,
count: i64,
}
#[repr(C)]
#[derive(ObjectRef, Clone)]
struct Counter {
data: ObjectArc<CounterObj>,
}
#[test]
fn test_types_without_reflect_register_no_reflection() {
let info = type_info::<CounterObj>();
assert_eq!(info.num_fields, 0);
assert!(info.metadata.is_null());
assert!(
TypeAttrColumn::lookup("__ffi_shallow_copy__")
.and_then(|column| column.get(CounterObj::type_index()))
.is_none()
);
}
mod no_imports {
#[repr(C)]
#[derive(tvm_ffi::derive::Object)]
#[object(type_key = "testing.rust.ReflectedNoImports", register)]
pub(super) struct LeafObj {
base_: super::PointObj,
#[reflect]
pub w: i64,
}
#[repr(C)]
#[derive(tvm_ffi::derive::ObjectRef, Clone)]
pub(super) struct Leaf {
pub data: tvm_ffi::ObjectArc<LeafObj>,
}
pub(super) fn leaf(w: i64) -> Leaf {
Leaf {
data: tvm_ffi::ObjectArc::new(LeafObj {
base_: super::point_obj(0, 0.0, ""),
w,
}),
}
}
}
#[test]
fn test_derives_need_nothing_in_scope() {
let leaf = no_imports::leaf(9);
let w = FieldGetter::new(no_imports::LeafObj::type_index(), "w").unwrap();
assert_eq!(w.get::<_, i64>(&*leaf.data).unwrap(), 9);
}
#[repr(C)]
#[derive(Object)]
#[object(type_key = "testing.rust.DuplicateMethod", register, reflection = Self::reflect_methods)]
struct DuplicateMethodObj {
base_: Object,
}
impl DuplicateMethodObj {
fn reflect_methods(def: &mut ObjectDef<Self>) {
def.def(
"same",
|_: tvm_ffi::object::ObjectRef| -> Result<i64> { Ok(1) },
"",
)
.def(
"same",
|_: tvm_ffi::object::ObjectRef| -> Result<i64> { Ok(2) },
"",
);
}
}
#[test]
fn test_duplicate_method_names_fail_the_registration() {
let error = tvm_ffi::run_static_init_blocks().unwrap_err();
assert!(
error
.message()
.contains("duplicate method `same` of `testing.rust.DuplicateMethod`")
);
}
#[test]
fn test_native_function() -> Result<()> {
let big = |value: i128| Any::from(BigInt::from(value));
let column = TypeAttrColumn::lookup("__any_equal__").expect("the column is registered");
let hook = column
.get(big(1 << 100).type_index())
.expect("the hook is registered");
let equal: NativeFunction<(&Any, &Any), bool> = unsafe { NativeFunction::from_any(hook)? };
assert!(equal.call((&big(1 << 100), &big(1 << 100)))?);
assert!(!equal.call((&big(1 << 100), &big(1 << 101)))?);
let error = equal
.call((&big(1 << 100), &Any::from(String::from("1"))))
.unwrap_err();
assert_eq!(error.kind(), TYPE_ERROR);
let get_x = Function::from_typed(|p: Point| -> Result<i64> { Ok(p.data.x) });
let hook: NativeFunction<(&PointObj,), i64> =
unsafe { NativeFunction::from_any(get_x.clone().into())? };
let p = point(3, 0.5, "p");
assert_eq!(hook.call((&*p.data,))?, 3);
let mismatch: NativeFunction<(&Point,), String> =
unsafe { NativeFunction::from_any(get_x.into())? };
let error = mismatch.call((&p,)).unwrap_err();
assert_eq!(error.message(), "Packed hook result type mismatch");
let x_of = |p: &PointObj| -> Result<i64> {
match p.x {
0 => Err(Error::new(VALUE_ERROR, "zero")),
x => Ok(x),
}
};
let hook = NativeFunction::<(&PointObj,), i64>::from(x_of);
unsafe { TypeAttrDef::<PointObj>::new().set_native_fn_attr("testing.x_of", hook)? };
let stored = TypeAttrColumn::lookup("testing.x_of")
.unwrap()
.get(PointObj::type_index());
let x_of: NativeFunction<(&PointObj,), i64> =
unsafe { NativeFunction::from_any(stored.unwrap())? };
assert_eq!(x_of.call((&*p.data,))?, 3);
let error = x_of.call((&*point(0, 0.5, "p").data,)).unwrap_err();
assert_eq!(error.kind(), VALUE_ERROR);
assert!(unsafe { NativeFunction::<()>::from_any(Any::from(1_i64)) }.is_err());
struct RawPointer;
impl From<RawPointer> for Any {
fn from(_: RawPointer) -> Any {
Any::from(std::ptr::null_mut::<std::ffi::c_void>())
}
}
let error = TypeAttrDef::<PointObj>::new()
.set_attr("testing.raw", RawPointer)
.err()
.unwrap();
assert_eq!(error.kind(), TYPE_ERROR);
Ok(())
}