Allow storing Option<DynGd<T>> in arrays

Author: Bromeon

godot-core/src/meta/args/as_arg.rs

@@ -143,6 +143,7 @@ where
     T: Inherits<Base>,
     Base: GodotClass,
 {
+    //noinspection RsConstantConditionIf - false positive in IDE for `T::IS_SAME_CLASS`.
     fn into_arg<'arg>(self) -> CowArg<'arg, Gd<Base>>
     where
         Self: 'arg,
@@ -199,7 +200,7 @@ where
     }
 }
 
-// Convert `DynGd` -> `Gd` (with upcast).
+/// Convert `DynGd` -> `Gd` (with upcast).
 impl<T, D, Base> AsArg<Gd<Base>> for &DynGd<T, D>
 where
     T: Inherits<Base>,
@@ -226,6 +227,29 @@ where
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Optional object (Gd + DynGd) impls
 
+/// Convert `&Gd` -> `Option<Gd>` (with upcast).
+impl<T, Base> AsArg<Option<Gd<Base>>> for &Gd<T>
+where
+    T: Inherits<Base>,
+    Base: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
+{
+    fn into_arg<'arg>(self) -> CowArg<'arg, Option<Gd<Base>>>
+    where
+        Self: 'arg,
+    {
+        // Upcasting to an owned value Gd<Base> requires cloning. Optimized path in into_ffi_arg().
+        CowArg::Owned(Some(self.clone().upcast::<Base>()))
+    }
+
+    fn into_ffi_arg<'arg>(self) -> FfiArg<'arg, Option<Gd<Base>>>
+    where
+        Self: 'arg,
+    {
+        let arg = ObjectArg::from_gd(self);
+        FfiArg::FfiObject(arg)
+    }
+}
+
 /// Convert `Option<&Gd>` -> `Option<Gd>` (with upcast).
 impl<T, Base> AsArg<Option<Gd<Base>>> for Option<&Gd<T>>
 where
@@ -252,21 +276,22 @@ where
     }
 }
 
-/// Convert `&Gd` -> `Option<Gd>` (with upcast).
-impl<T, Base> AsArg<Option<Gd<Base>>> for &Gd<T>
+/// Convert `&DynGd` -> `Option<DynGd>` (with upcast).
+impl<T, D, Base> AsArg<Option<DynGd<Base, D>>> for &DynGd<T, D>
 where
     T: Inherits<Base>,
+    D: ?Sized,
     Base: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
 {
-    fn into_arg<'arg>(self) -> CowArg<'arg, Option<Gd<Base>>>
+    fn into_arg<'arg>(self) -> CowArg<'arg, Option<DynGd<Base, D>>>
     where
         Self: 'arg,
     {
-        // Upcasting to an owned value Gd<Base> requires cloning. Optimized path in into_ffi_arg().
-        CowArg::Owned(Some(self.clone().upcast::<Base>()))
+        // Upcasting to an owned value DynGd<Base, D> requires cloning. Optimized path in into_ffi_arg().
+        CowArg::Owned(Some(self.clone().upcast()))
     }
 
-    fn into_ffi_arg<'arg>(self) -> FfiArg<'arg, Option<Gd<Base>>>
+    fn into_ffi_arg<'arg>(self) -> FfiArg<'arg, Option<DynGd<Base, D>>>
     where
         Self: 'arg,
     {
@@ -299,6 +324,34 @@ where
     }
 }
 
+/// Convert `Option<&DynGd>` -> `Option<DynGd>` (with upcast).
+impl<T, D, Base> AsArg<Option<DynGd<Base, D>>> for Option<&DynGd<T, D>>
+where
+    T: Inherits<Base>,
+    D: ?Sized,
+    Base: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
+{
+    fn into_arg<'arg>(self) -> CowArg<'arg, Option<DynGd<Base, D>>>
+    where
+        Self: 'arg,
+    {
+        // Upcasting to an owned value Gd<Base> requires cloning. Optimized path in into_ffi_arg().
+        match self {
+            Some(gd_ref) => AsArg::into_arg(gd_ref),
+            None => CowArg::Owned(None),
+        }
+    }
+
+    fn into_ffi_arg<'arg>(self) -> FfiArg<'arg, Option<DynGd<Base, D>>>
+    where
+        Self: 'arg,
+    {
+        let option_gd: Option<&Gd<T>> = self.map(|v| &**v); // as_deref() not working.
+        let arg = ObjectArg::from_option_gd(option_gd);
+        FfiArg::FfiObject(arg)
+    }
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Public helper functions (T|&T -> AsArg)
 

godot-core/src/meta/sealed.rs

@@ -62,6 +62,7 @@ impl<T: ArrayElement> Sealed for Array<T> {}
 impl<T: GodotClass> Sealed for Gd<T> {}
 impl<T: GodotClass> Sealed for RawGd<T> {}
 impl<T: GodotClass, D: ?Sized> Sealed for DynGd<T, D> {}
+impl<T: GodotClass, D: ?Sized + 'static> Sealed for Option<DynGd<T, D>> {}
 impl<T> Sealed for Option<T>
 where
     T: GodotType,

godot-core/src/obj/dyn_gd.rs

@@ -606,6 +606,16 @@ where
     }
 }
 
+impl<T, D> meta::ArrayElement for Option<DynGd<T, D>>
+where
+    T: GodotClass,
+    D: ?Sized + 'static,
+{
+    fn element_type_string() -> String {
+        DynGd::<T, D>::element_type_string()
+    }
+}
+
 impl<T, D> Var for DynGd<T, D>
 where
     T: GodotClass,

itest/rust/src/object_tests/dyn_gd_test.rs

@@ -430,6 +430,44 @@ fn dyn_gd_store_in_godot_array() {
     */
 }
 
+#[itest]
+fn dyn_gd_as_arg() {
+    let refc_health = Gd::from_object(RefcHealth { hp: 42 }).into_dyn();
+    let node_health = foreign::NodeHealth::new_alloc().into_dyn();
+    let typed_none = None::<&DynGd<RefcHealth, dyn Health>>;
+
+    // Array<DynGd>.
+    let array: Array<DynGd<Object, dyn Health>> = array![&refc_health, &node_health];
+    assert_eq!(array.len(), 2);
+
+    let first = array.at(0);
+    assert_eq!(first.dyn_bind().get_hitpoints(), 42);
+
+    let second = array.at(1);
+    assert_eq!(second.dyn_bind().get_hitpoints(), 100);
+
+    // Array<Option<DynGd>>.
+    let opt_array: Array<Option<DynGd<Object, dyn Health>>> = array![
+        Some(&refc_health),
+        Some(&node_health),
+        typed_none,
+        // Gd::null_arg(),
+    ];
+    assert_eq!(opt_array.len(), 3);
+
+    let first = opt_array.at(0).expect("element 0 is Some");
+    assert_eq!(first.dyn_bind().get_hitpoints(), 42);
+
+    let second = opt_array.at(1).expect("element 1 is Some");
+    assert_eq!(second.dyn_bind().get_hitpoints(), 100);
+
+    let third = opt_array.at(2);
+    assert!(third.is_none(), "element 2 is None");
+
+    // Clean up manually managed objects.
+    opt_array.at(1).unwrap().free();
+}
+
 #[itest]
 fn dyn_gd_error_unregistered_trait() {
     trait UnrelatedTrait {}