Fixed bug causing ConnectHandle::is_connected() to sometimes panic.

A ConnectHandle created from a connection from A to B would panic if `is_connected()` or `disconnect()` was called after A was freed.
Fixed by `is_connected()` checking if the contained object is valid through `is_instance_valid()`.

Author: andersgaustad

godot-core/src/registry/signal/connect_handle.rs

@@ -54,6 +54,10 @@ impl ConnectHandle {
     /// [`disconnect()`][Self::disconnect] -- e.g. through [`Signal::disconnect()`][crate::builtin::Signal::disconnect] or
     /// [`Object::disconnect()`][crate::classes::Object::disconnect].
     pub fn is_connected(&self) -> bool {
+        if !self.receiver_object.is_instance_valid() {
+            return false;
+        }
+
         self.receiver_object
             .is_connected(&*self.signal_name, &self.callable)
     }

itest/rust/src/builtin_tests/containers/signal_disconnect_test.rs

@@ -152,10 +152,14 @@ fn handle_recognizes_direct_object_disconnect() {
     })
 }
 
-#[itest(skip)]
-fn handle_recognizes_freed_object() {
-    // TODO
-    // We should define what happens when either the broadcasting object or (potential) receiving object is freed.
+#[itest]
+fn test_handle_after_freeing_broadcaster() {
+    test_freed_nodes(true);
+}
+
+#[itest]
+fn test_handle_after_freeing_receiver() {
+    test_freed_nodes(false);
 }
 
 // Helper functions:
@@ -229,6 +233,42 @@ fn test_handle_recognizes_non_valid_state(disconnect_function: impl FnOnce(&mut
     obj.free();
 }
 
+fn test_freed_nodes(free_broadcaster_first: bool) {
+    let broadcaster = SignalDisc::new_alloc();
+    let receiver = SignalDisc::new_alloc();
+
+    let handle = broadcaster
+        .signals()
+        .my_signal()
+        .connect_other(&receiver, |r| {
+            r.increment_self();
+        });
+
+    let (to_free, other) = if free_broadcaster_first {
+        (broadcaster, receiver)
+    } else {
+        (receiver, broadcaster)
+    };
+
+    // Free one of the nodes, and check if the handle thinks the objects are connected.
+    // If the broadcaster is freed, its signals to other objects is implicitly freed as well. Thus, the handle should not be connected.
+    // If the receiver is freed, the connection between the valid broadcaster and the non-valid freed object still exists.
+    // In the latter case, the connection can - and probably should - be freed with disconnect().
+    to_free.free();
+    let is_connected = handle.is_connected();
+    assert_ne!(
+        free_broadcaster_first, is_connected,
+        "Handle should only return false if broadcasting is freed!"
+    );
+
+    // It should be possible to discconect a connection between a valid broadcaster and a non-valid receiver.
+    if is_connected {
+        handle.disconnect();
+    }
+
+    other.free();
+}
+
 fn has_connections(obj: &Gd<SignalDisc>) -> bool {
     !obj.get_signal_connection_list("my_signal").is_empty()
 }