Add OnEditor<T>, remove Export implementations for DynGd and Gd

- Clean up `OnEditor<...>` bounds.
- Make `DynGd<T: Inherits<Resource>, D>` exportable with `Option` & `DynGd`
- Fix export for `DynGd<T: Inherits<Resource> + Bounds<Declarer = bounds::DeclUser>, D>`
- Code tweaks according to CR

Author: Yarwin

godot-core/src/builtin/collections/array.rs

@@ -1102,9 +1102,9 @@ where
 
 impl<T: ArrayElement> BuiltinExport for Array<T> {}
 
-impl<T: GodotClass> Export for Array<Gd<T>>
+impl<T> Export for Array<Gd<T>>
 where
-    T: Bounds<Exportable = bounds::Yes>,
+    T: GodotClass + Bounds<Exportable = bounds::Yes>,
 {
     fn export_hint() -> PropertyHintInfo {
         PropertyHintInfo::export_array_element::<Gd<T>>()
@@ -1121,7 +1121,7 @@ where
 /// Consider exporting `Array<Gd<T>>` instead of `Array<DynGd<T, D>>` for user-declared GDExtension classes.
 impl<T: GodotClass, D> Export for Array<DynGd<T, D>>
 where
-    T: GodotClass + Bounds<Exportable = bounds::Yes, Declarer = bounds::DeclEngine>,
+    T: GodotClass + Bounds<Exportable = bounds::Yes>,
     D: ?Sized + 'static,
 {
     fn export_hint() -> PropertyHintInfo {

godot-core/src/obj/dyn_gd.rs

@@ -142,48 +142,9 @@ use std::{fmt, ops};
 /// Exporting `DynGd<T, D>` is possible only via [`OnEditor`] or [`Option`].
 /// `DynGd<T, D>` can also be exported directly as an element of an array such as `Array<DynGd<T, D>>`.
 ///
-/// Since `DynGd<T, D>` expresses shared functionality `D` among classes inheriting `T`,
-/// `#[export]` for `DynGd<T, D>` where `T` is a concrete Rust class is not allowed.
-///
-/// ```compile_fail
-///
-///  use godot::prelude::*;
-///
-/// trait Health { /* ... */ }
-///
-/// #[derive(GodotClass)]
-/// # #[class(init)]
-/// struct Monster { /* ... */ }
-///
-/// #[godot_dyn]
-/// impl Health for Monster { /* ... */ }
-///
-/// #[derive(GodotClass)]
-/// #[class(init, base = Node)]
-/// struct MyClass {
-///     #[export]
-///     dyn_concrete: Option<DynGd<Monster, dyn Health>>,
-/// }
-/// ```
-///
-/// Consider using `Gd<T>` instead in such cases:
-///
-/// ```
-///  use godot::prelude::*;
-///
-/// #[derive(GodotClass)]
-/// #[class(init, base = Node)]
-/// struct Monster { /* ... */ }
-///
-/// /* ... */
-///
-/// #[derive(GodotClass)]
-/// #[class(init, base = Node)]
-/// struct MyClass {
-///     #[export]
-///     dyn_concrete: Option<Gd<Monster>>,
-/// }
-/// ```
+/// Since `DynGd<T, D>` represents shared functionality `D` across classes inheriting from `T`,
+/// consider using `#[export] Gd<T>` instead of `#[export] DynGd<T, D>`
+/// in cases when `T` is a concrete Rust `GodotClass`.
 ///
 /// ## Node based classes
 ///
@@ -562,7 +523,7 @@ where
 /// Consider exporting `Option<Gd<T>>` instead of `Option<DynGd<T, D>>` for user-declared GDExtension classes.
 impl<T, D> Export for Option<DynGd<T, D>>
 where
-    T: GodotClass + Bounds<Exportable = bounds::Yes, Declarer = bounds::DeclEngine>,
+    T: GodotClass + Bounds<Exportable = bounds::Yes>,
     D: ?Sized + 'static,
 {
     fn export_hint() -> PropertyHintInfo {
@@ -599,12 +560,12 @@ where
     D: ?Sized + 'static,
 {
     fn get_property(&self) -> Self::Via {
-        OnEditor::<DynGd<T, D>>::get_property_inner(self)
+        Self::get_property_inner(self)
     }
 
     fn set_property(&mut self, value: Self::Via) {
         // `set_property` can't be delegated to Gd<T>, since we have to set `erased_obj` as well.
-        OnEditor::<DynGd<T, D>>::set_property_inner(self, value)
+        Self::set_property_inner(self, value)
     }
 }
 
@@ -613,8 +574,8 @@ where
 /// Consider exporting `OnEditor<Gd<T>>` instead of `OnEditor<DynGd<T, D>>` for user-declared GDExtension classes.
 impl<T, D> Export for OnEditor<DynGd<T, D>>
 where
-    OnEditor<DynGd<T, D>>: Var,
-    T: GodotClass + Bounds<Exportable = bounds::Yes, Declarer = bounds::DeclEngine>,
+    Self: Var,
+    T: GodotClass + Bounds<Exportable = bounds::Yes>,
     D: ?Sized + 'static,
 {
     fn export_hint() -> PropertyHintInfo {

godot-core/src/obj/gd.rs

@@ -937,21 +937,20 @@ where
 impl<T> Var for OnEditor<Gd<T>>
 where
     T: GodotClass,
-    OnEditor<Gd<T>>: GodotConvert<Via = Option<<Gd<T> as GodotConvert>::Via>>,
 {
     fn get_property(&self) -> Self::Via {
-        OnEditor::<Gd<T>>::get_property_inner(self)
+        Self::get_property_inner(self)
     }
 
     fn set_property(&mut self, value: Self::Via) {
-        OnEditor::<Gd<T>>::set_property_inner(self, value)
+        Self::set_property_inner(self, value)
     }
 }
 
 impl<T> Export for OnEditor<Gd<T>>
 where
+    Self: Var,
     T: GodotClass + Bounds<Exportable = bounds::Yes>,
-    OnEditor<Gd<T>>: Var,
 {
     fn export_hint() -> PropertyHintInfo {
         PropertyHintInfo::export_gd::<T>()

godot-core/src/obj/oneditor.rs

@@ -166,6 +166,9 @@ pub(crate) enum OnEditorState<T> {
     Initialized(T),
 }
 
+/// `OnEditor<T>` is usable only for properties – which is enforced via `Var` and `FromGodot` bounds.
+///
+/// Furthermore, `PartialEq` is needed to compare against uninitialized sentinel values.
 impl<T: Var + FromGodot + PartialEq> OnEditor<T> {
     /// Initializes invalid `OnEditor<T>` with given value.
     ///

godot-core/src/registry/class.rs

@@ -370,10 +370,12 @@ where
     // For example – don't include Nodes or Objects while creating hint_string for Resource.
     let relations_iter = relations.iter().filter_map(|implementor| {
         // TODO – check if caching it (using is_derived_base_cached) yields any benefits.
-        if ClassDb::singleton().is_parent_class(
-            &implementor.parent_class_name?.to_string_name(),
-            &T::class_name().to_string_name(),
-        ) {
+        if implementor.parent_class_name? == T::class_name()
+            || ClassDb::singleton().is_parent_class(
+                &implementor.parent_class_name?.to_string_name(),
+                &T::class_name().to_string_name(),
+            )
+        {
             Some(implementor)
         } else {
             None

itest/godot/ManualFfiTests.gd

@@ -309,19 +309,19 @@ func test_option_export():
 	assert_eq(obj.optional_export, null)
 
 	var test_node := Node.new()
+	var test_resource := Resource.new()
 
 	obj.optional = test_node
-	obj.optional_export = test_node
+	obj.optional_export = test_resource
 	assert_eq(obj.optional, test_node)
-	assert_eq(obj.optional_export, test_node)
+	assert_eq(obj.optional_export, test_resource)
 
 	obj.optional = null
 	obj.optional_export = null
 	assert_eq(obj.optional, null)
 	assert_eq(obj.optional_export, null)
 
 	test_node.free()
-	obj.free()
 
 func test_func_rename():
 	var func_rename := FuncObj.new()

itest/rust/src/register_tests/option_ffi_test.rs

@@ -5,7 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use godot::classes::{Node, Object, RefCounted};
+use godot::classes::{Node, Object, RefCounted, Resource};
 use godot::meta::GodotType;
 use godot::obj::{Gd, NewAlloc, NewGd, RawGd};
 use godot::register::{godot_api, GodotClass};
@@ -97,11 +97,11 @@ impl OptionFfiTest {
 }
 
 #[derive(GodotClass)]
-#[class(init, base=Node)]
+#[class(init)]
 struct OptionExportFfiTest {
     #[var]
     optional: Option<Gd<Node>>,
 
     #[export]
-    optional_export: Option<Gd<Node>>,
+    optional_export: Option<Gd<Resource>>,
 }