Test subtyping relation break (skipped) + Gd::eq() on dead objects

Author: Bromeon

godot-core/src/obj/gd.rs

@@ -220,7 +220,7 @@ impl<T: GodotClass> Gd<T> {
         // Initialize instance ID cache
         let id = unsafe { interface_fn!(object_get_instance_id)(obj.obj_sys()) };
         let instance_id = InstanceId::try_from_u64(id)
-            .expect("instance ID must be non-zero at time of initialization");
+            .expect("Gd initialization failed; did you call share() on a dead instance?");
         obj.cached_instance_id.set(Some(instance_id));
 
         obj
@@ -452,7 +452,7 @@ where
         // If ref_counted returned None, that means the instance was destroyed
         assert!(
             ref_counted == Some(false) && self.is_instance_valid(),
-            "called free() on already destroyed obj"
+            "called free() on already destroyed object"
         );
 
         // This destroys the Storage instance, no need to run destructor again

itest/rust/src/object_test.rs

@@ -15,6 +15,7 @@ use godot::obj::{Inherits, Share};
 use godot::sys::GodotFfi;
 
 use std::cell::RefCell;
+use std::mem;
 use std::rc::Rc;
 
 // TODO:
@@ -33,6 +34,39 @@ fn object_construct_value() {
     assert_eq!(obj.bind().value, 222);
 }
 
+// TODO(#23): DerefMut on Gd pointer may be used to break subtyping relations
+#[itest(skip)]
+fn object_subtype_swap() {
+    let mut a: Gd<Node> = Node::new_alloc();
+    let mut b: Gd<Node3D> = Node3D::new_alloc();
+
+    /*
+    let a_id = a.instance_id();
+    let b_id = b.instance_id();
+    let a_class = a.get_class();
+    let b_class = b.get_class();
+
+    dbg!(a_id);
+    dbg!(b_id);
+    dbg!(&a_class);
+    dbg!(&b_class);
+    println!("..swap..");
+    */
+
+    mem::swap(&mut *a, &mut *b);
+
+    /*
+    dbg!(a_id);
+    dbg!(b_id);
+    dbg!(&a_class);
+    dbg!(&b_class);
+    */
+
+    // This should not panic
+    a.free();
+    b.free();
+}
+
 #[itest]
 fn object_user_roundtrip_return() {
     let value: i16 = 17943;
@@ -192,6 +226,31 @@ fn object_engine_eq() {
     b1.free();
 }
 
+#[itest]
+fn object_dead_eq() {
+    let a = Node3D::new_alloc();
+    let b = Node3D::new_alloc();
+    let b2 = b.share();
+
+    // Destroy b1 without consuming it
+    b.share().free();
+
+    {
+        let lhs = a.share();
+        expect_panic("Gd::eq() panics when one operand is dead", move || {
+            let _ = lhs == b;
+        });
+    }
+    {
+        let rhs = a.share();
+        expect_panic("Gd::ne() panics when one operand is dead", move || {
+            let _ = b2 != rhs;
+        });
+    }
+
+    a.free();
+}
+
 #[itest]
 fn object_user_convert_variant() {
     let value: i16 = 17943;
@@ -485,7 +544,7 @@ fn object_engine_refcounted_free() {
     let node = RefCounted::new();
     let node2 = node.share().upcast::<Object>();
 
-    expect_panic("calling free() on RefCounted obj", || node2.free())
+    expect_panic("calling free() on RefCounted object", || node2.free())
 }
 
 #[itest]