Add support for assoc items

- Refactor tests - remove checking for second trait (since we do it wit associated type one), reduce number of test cases, don't double-test methods that check for godot-related DynGd interactions if it is not absolutely necessary.

Author: Yarwin

itest/rust/src/object_tests/dyn_gd_test.rs

@@ -76,34 +76,14 @@ fn deal_20_damage(h: &mut dyn Health) {
     h.deal_damage(20);
 }
 
-#[itest]
-fn dyn_gd_with_assoc_trait_creation_deref() {
-    let node = foreign::NodeHealth::new_alloc();
-    let original_id = node.instance_id();
-
-    let mut node = node.into_dyn::<dyn HealthWithAssociatedType<HealthType = u8>>();
-
-    let dyn_id = node.instance_id();
-    assert_eq!(dyn_id, original_id);
-
-    set_health_report_to_62(&mut *node.dyn_bind_mut());
-    assert_eq!(node.dyn_bind().get_report(), 62);
-
-    node.free();
-}
-
-fn set_health_report_to_62(h: &mut dyn HealthWithAssociatedType<HealthType = u8>) {
-    h.set_report(62);
-}
-
 #[itest]
 fn dyn_gd_upcast() {
     let original = foreign::NodeHealth::new_alloc();
     let original_copy = original.clone();
 
     let concrete = original.clone().into_dyn::<dyn Health>();
     let concrete_with_associated_type =
-        original.into_dyn::<dyn HealthWithAssociatedType<HealthType = u8>>();
+        original.into_dyn::<dyn HealthWithAssociatedType<HealthType = f32>>();
 
     let mut node = concrete.clone().upcast::<Node>();
     let object = concrete.upcast::<Object>();
@@ -115,12 +95,16 @@ fn dyn_gd_upcast() {
 
     // Ensure applied to the object polymorphically. Concrete object can access bind(), no dyn_bind().
     assert_eq!(original_copy.bind().get_hitpoints(), 75);
-    assert_eq!(original_copy.bind().get_report(), 75);
+    assert_eq!(original_copy.bind().get_report(), 42.0);
 
     // Check also another angle (via Object). Here dyn_bind().
     assert_eq!(object.dyn_bind().get_hitpoints(), 75);
+
+    let object = concrete_with_associated_type.clone().upcast::<Object>();
+    assert_eq!(object.dyn_bind().get_report(), 42.0);
+
     // via DynGd with associated type
-    assert_eq!(concrete_with_associated_type.dyn_bind().get_report(), 75);
+    assert_eq!(concrete_with_associated_type.dyn_bind().get_report(), 42.0);
 
     node.free();
 }
@@ -173,14 +157,9 @@ fn dyn_gd_debug() {
     let expected = format!(".:DynGd {{ id: {id}, class: RefcHealth, trait: dyn Health }}:.");
 
     assert_eq!(actual, expected);
-}
 
-#[itest]
-fn dyn_gd_with_associated_type_debug() {
     let obj: DynGd<RefcHealth, dyn HealthWithAssociatedType<HealthType = u8>> =
-        Gd::from_object(RefcHealth { hp: 20 }).into_dyn();
-    let id = obj.instance_id();
-
+        obj.into_gd().into_dyn();
     let actual = format!(".:{obj:?}:.");
     let expected = format!(".:DynGd {{ id: {id}, class: RefcHealth, trait: dyn HealthWithAssociatedType<HealthType = u8> }}:.");
 
@@ -210,7 +189,6 @@ fn dyn_gd_with_associated_type_display() {
 
 #[itest]
 fn dyn_gd_eq() {
-    // Eq checks for DynGds inner objects, therefore it works the same for DynGd with associated type.
     let gd = Gd::from_object(RefcHealth { hp: 55 });
     let a: DynGd<RefcHealth, dyn Health> = gd.clone().into_dyn();
     let b: DynGd<RefcHealth, dyn Health> = gd.into_dyn();
@@ -227,7 +205,6 @@ fn dyn_gd_eq() {
 
 #[itest]
 fn dyn_gd_hash() {
-    // Hash uses DynGds inner objects therefore it works the same for DynGd with associated type.
     use godot::sys::hash_value;
 
     let gd = Gd::from_object(RefcHealth { hp: 55 });
@@ -334,19 +311,6 @@ fn dyn_gd_pass_to_godot_api() {
     parent.free();
 }
 
-#[itest]
-fn dyn_gd_with_associated_type_pass_to_godot_api() {
-    let child = foreign::NodeHealth::new_alloc()
-        .into_dyn::<dyn HealthWithAssociatedType<HealthType = u8>>();
-
-    let mut parent = Node::new_alloc();
-    parent.add_child(&child);
-
-    assert_eq!(child.get_parent().as_ref(), Some(&parent));
-
-    parent.free();
-}
-
 #[itest]
 fn dyn_gd_variant_conversions() {
     let original = Gd::from_object(RefcHealth { hp: 11 }).into_dyn::<dyn Health>();
@@ -388,48 +352,6 @@ fn dyn_gd_variant_conversions() {
     assert_eq!(back.instance_id(), original_id);
 }
 
-#[itest]
-fn dyn_gd_with_associated_type_variant_conversions() {
-    let original = Gd::from_object(RefcHealth { hp: 11 })
-        .into_dyn::<dyn HealthWithAssociatedType<HealthType = u8>>();
-    let original_id = original.instance_id();
-    let refc = original.into_gd().upcast::<RefCounted>();
-
-    let variant = refc.to_variant();
-
-    // Convert to different levels of DynGd:
-
-    let back: DynGd<RefcHealth, dyn HealthWithAssociatedType<HealthType = u8>> = variant.to();
-    assert_eq!(back.bind().get_report(), 11);
-    assert_eq!(back.instance_id(), original_id);
-
-    let back: DynGd<RefCounted, dyn HealthWithAssociatedType<HealthType = u8>> = variant.to();
-    assert_eq!(back.dyn_bind().get_report(), 11);
-    assert_eq!(back.instance_id(), original_id);
-
-    let back: DynGd<Object, dyn HealthWithAssociatedType<HealthType = u8>> = variant.to();
-    assert_eq!(back.dyn_bind().get_report(), 11);
-    assert_eq!(back.instance_id(), original_id);
-
-    // convert to different DynGd
-
-    let other: DynGd<RefcHealth, dyn Health> = variant.to();
-    assert_eq!(other.dyn_bind().get_hitpoints(), 11);
-    assert_eq!(other.instance_id(), original_id);
-
-    // Convert to different levels of Gd:
-
-    let back: Gd<RefcHealth> = variant.to();
-    assert_eq!(back.bind().get_report(), 11);
-    assert_eq!(back.instance_id(), original_id);
-
-    let back: Gd<RefcHealth> = variant.to();
-    assert_eq!(back.instance_id(), original_id);
-
-    let back: Gd<Object> = variant.to();
-    assert_eq!(back.instance_id(), original_id);
-}
-
 #[itest]
 fn dyn_gd_store_in_godot_array() {
     let a = Gd::from_object(RefcHealth { hp: 33 }).into_dyn::<dyn Health>();
@@ -447,14 +369,9 @@ fn dyn_gd_store_in_godot_array() {
 fn dyn_gd_with_associated_type_store_in_godot_array() {
     let a: DynGd<RefcHealth, dyn HealthWithAssociatedType<HealthType = u8>> =
         Gd::from_object(RefcHealth { hp: 33 }).into_dyn();
-    let b = foreign::NodeHealth::new_alloc().into_dyn();
-
-    let array: Array<DynGd<Object, _>> = array![&a.upcast(), &b.upcast()];
 
+    let array: Array<DynGd<Object, _>> = array![&a.upcast()];
     assert_eq!(array.at(0).dyn_bind().get_report(), 33);
-    assert_eq!(array.at(1).dyn_bind().get_report(), 42);
-
-    array.at(1).free();
 }
 
 #[itest]
@@ -478,6 +395,7 @@ fn dyn_gd_error_unregistered_trait() {
 
     let back =
         variant.try_to::<DynGd<RefcHealth, dyn HealthWithAssociatedType<HealthType = i64>>>();
+
     let err = back.expect_err("DynGd::try_to() should have failed");
     let expected_err = {
         format!("trait `dyn HealthWithAssociatedType<HealthType = i64>` has not been registered with #[godot_dyn]: {gd:?}")
@@ -559,18 +477,6 @@ fn dyn_gd_free_while_dyn_bound() {
     obj.free();
 }
 
-#[itest]
-fn dyn_gd_multiple_traits() {
-    let obj = foreign::NodeHealth::new_alloc();
-    let original_id = obj.instance_id();
-
-    let obj = obj.into_dyn::<dyn InstanceIdProvider>().upcast::<Node>();
-    let id = obj.dyn_bind().get_id_dynamic();
-    assert_eq!(id, original_id);
-
-    obj.free();
-}
-
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Example symbols
 
@@ -657,36 +563,16 @@ impl Health for foreign::NodeHealth {
     }
 }
 
+// Implementation created only to register the DynGd `HealthWithAssociatedType<HealthType=f32>` trait.
 #[godot_dyn]
 impl HealthWithAssociatedType for foreign::NodeHealth {
-    type HealthType = u8;
+    type HealthType = f32;
 
     fn get_report(&self) -> Self::HealthType {
-        if self.base().has_meta("hp") {
-            self.base().get_meta("hp").to::<u8>()
-        } else {
-            42 // initial value, if nothing set.
-        }
+        42.0
     }
 
-    fn set_report(&mut self, new: Self::HealthType) {
-        self.base_mut().set_meta("hp", &new.to_variant());
-    }
-}
-
-// ----------------------------------------------------------------------------------------------------------------------------------------------
-// Check that one class can implement two or more traits.
-
-// Pointless trait, but tests access to object.
-trait InstanceIdProvider {
-    fn get_id_dynamic(&self) -> InstanceId;
-}
-
-#[godot_dyn]
-impl InstanceIdProvider for foreign::NodeHealth {
-    fn get_id_dynamic(&self) -> InstanceId {
-        self.base().instance_id()
-    }
+    fn set_report(&mut self, _new: Self::HealthType) {}
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
@@ -698,16 +584,5 @@ struct RefcDynGdExporter {
     #[var]
     first: Option<DynGd<Object, dyn Health>>,
     #[export]
-    second: Option<DynGd<foreign::NodeHealth, dyn InstanceIdProvider>>,
-}
-
-#[godot_dyn]
-impl HealthWithAssociatedType for RefcDynGdExporter {
-    type HealthType = f32;
-
-    fn get_report(&self) -> Self::HealthType {
-        1.
-    }
-
-    fn set_report(&mut self, _new: Self::HealthType) {}
+    second: Option<DynGd<foreign::NodeHealth, dyn HealthWithAssociatedType<HealthType = f32>>>,
 }