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

- Create proper blanket implementation for Godot Types other than Gd<T>
- Fix nonsensical bounds
- Fix docs examples (don't wrap)
- Formatting fixes
- Move Gd<T>::export_info to PropertyHintInfo::export_gd.

Author: Yarwin

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

@@ -1086,9 +1086,9 @@ impl<T: ArrayElement> Var for Array<T> {
     }
 }
 
-impl<T: Export> Export for Array<T>
+impl<T> Export for Array<T>
 where
-    T: ArrayElement,
+    T: ArrayElement + Export,
 {
     fn export_hint() -> PropertyHintInfo {
         // If T == Variant, then we return "Array" builtin type hint.
@@ -1103,15 +1103,14 @@ where
 impl<T: GodotClass> Export for Array<Gd<T>>
 where
     T: Bounds<Exportable = bounds::Yes>,
-    Gd<T>: ArrayElement,
 {
     fn export_hint() -> PropertyHintInfo {
         PropertyHintInfo::export_array_element::<Gd<T>>()
     }
 
     #[doc(hidden)]
     fn as_node_class() -> Option<ClassName> {
-        Gd::<T>::as_node_class()
+        PropertyHintInfo::object_as_node_class::<T>()
     }
 }
 

godot-core/src/meta/property_info.rs

@@ -10,9 +10,9 @@ use crate::global::{PropertyHint, PropertyUsageFlags};
 use crate::meta::{
     element_godot_type_name, ArrayElement, ClassName, GodotType, PackedArrayElement,
 };
-use crate::obj::{EngineBitfield, EngineEnum};
+use crate::obj::{bounds, Bounds, EngineBitfield, EngineEnum, GodotClass};
 use crate::registry::property::{Export, Var};
-use crate::sys;
+use crate::{classes, sys};
 use godot_ffi::VariantType;
 
 /// Describes a property in Godot.
@@ -302,4 +302,26 @@ impl PropertyHintInfo {
             hint_string: GString::from(T::element_type_string()),
         }
     }
+
+    pub fn export_gd<T: GodotClass + Bounds<Exportable = bounds::Yes>>() -> Self {
+        let hint = if T::inherits::<classes::Resource>() {
+            PropertyHint::RESOURCE_TYPE
+        } else if T::inherits::<classes::Node>() {
+            PropertyHint::NODE_TYPE
+        } else {
+            unreachable!("classes not inheriting from Resource or Node should not be exportable")
+        };
+
+        // Godot does this by default too; the hint is needed when the class is a resource/node,
+        // but doesn't seem to make a difference otherwise.
+        let hint_string = T::class_name().to_gstring();
+
+        Self { hint, hint_string }
+    }
+
+    #[doc(hidden)]
+    pub fn object_as_node_class<T: GodotClass + Bounds<Exportable = bounds::Yes>>(
+    ) -> Option<ClassName> {
+        T::inherits::<classes::Node>().then(|| T::class_name())
+    }
 }

godot-core/src/obj/dyn_gd.rs

@@ -495,22 +495,6 @@ where
     }
 }
 
-impl<T, D> Export for Option<DynGd<T, D>>
-where
-    T: GodotClass + Bounds<Exportable = bounds::Yes>,
-    D: ?Sized + 'static,
-{
-    fn export_hint() -> PropertyHintInfo {
-        PropertyHintInfo {
-            hint_string: get_dyn_property_hint_string::<D>(),
-            ..Gd::<T>::export_hint()
-        }
-    }
-    fn as_node_class() -> Option<ClassName> {
-        Gd::<T>::as_node_class()
-    }
-}
-
 #[doc(hidden)]
 #[allow(clippy::derivable_impls)]
 impl<T, D> Default for OnEditor<DynGd<T, D>>
@@ -522,42 +506,18 @@ where
         OnEditor::null()
     }
 }
-
-impl<T, D> GodotConvert for OnEditor<DynGd<T, D>>
-where
-    T: GodotClass,
-    D: ?Sized,
-{
-    type Via = Option<<DynGd<T, D> as GodotConvert>::Via>;
-}
-
-impl<T, D> Var for OnEditor<DynGd<T, D>>
-where
-    T: GodotClass,
-    D: ?Sized + 'static,
-{
-    fn get_property(&self) -> Self::Via {
-        OnEditor::<DynGd<T, D>>::get_property(self)
-    }
-
-    fn set_property(&mut self, value: Self::Via) {
-        OnEditor::<DynGd<T, D>>::set_property(self, value)
-    }
-}
-
-impl<T, D> Export for OnEditor<DynGd<T, D>>
+impl<T, D> Export for Option<DynGd<T, D>>
 where
-    OnEditor<DynGd<T, D>>: Var,
     T: GodotClass + Bounds<Exportable = bounds::Yes>,
     D: ?Sized + 'static,
 {
     fn export_hint() -> PropertyHintInfo {
         PropertyHintInfo {
             hint_string: get_dyn_property_hint_string::<D>(),
-            ..Gd::<T>::export_hint()
+            ..PropertyHintInfo::export_gd::<T>()
         }
     }
     fn as_node_class() -> Option<ClassName> {
-        Gd::<T>::as_node_class()
+        PropertyHintInfo::object_as_node_class::<T>()
     }
 }

godot-core/src/obj/gd.rs

@@ -545,40 +545,6 @@ impl<T: GodotClass> Gd<T> {
         // Do not increment ref-count; assumed to be return value from FFI.
         sys::ptr_then(object_ptr, |ptr| Gd::from_obj_sys_weak(ptr))
     }
-
-    /// Provides `export_hint` to be used in exports with `Option<Gd<T>>` and `OnEditor<Gd<T>>`.
-    ///
-    /// `Gd<T>` by itself is non-nullable which works badly with Godot editor and might lead to
-    /// unavoidable memory leaks – thus the need to handle `#[export]` with algebraic types.
-    ///
-    /// See also: [#892](https://github.com/godot-rust/gdext/issues/892#issuecomment-2628955463)
-    #[doc(hidden)]
-    pub(crate) fn export_hint() -> PropertyHintInfo
-    where
-        T: Bounds<Exportable = bounds::Yes>,
-    {
-        let hint = if T::inherits::<classes::Resource>() {
-            PropertyHint::RESOURCE_TYPE
-        } else if T::inherits::<classes::Node>() {
-            PropertyHint::NODE_TYPE
-        } else {
-            unreachable!("classes not inheriting from Resource or Node should not be exportable")
-        };
-
-        // Godot does this by default too; the hint is needed when the class is a resource/node,
-        // but doesn't seem to make a difference otherwise.
-        let hint_string = T::class_name().to_gstring();
-
-        PropertyHintInfo { hint, hint_string }
-    }
-
-    #[doc(hidden)]
-    pub(crate) fn as_node_class() -> Option<ClassName>
-    where
-        T: Bounds<Exportable = bounds::Yes>,
-    {
-        T::inherits::<classes::Node>().then(|| T::class_name())
-    }
 }
 
 /// _The methods in this impl block are only available for objects `T` that are manually managed,
@@ -942,12 +908,12 @@ where
     Option<Gd<T>>: Var,
 {
     fn export_hint() -> PropertyHintInfo {
-        Gd::<T>::export_hint()
+        PropertyHintInfo::export_gd::<T>()
     }
 
     #[doc(hidden)]
     fn as_node_class() -> Option<ClassName> {
-        Gd::<T>::as_node_class()
+        PropertyHintInfo::object_as_node_class::<T>()
     }
 }
 
@@ -959,43 +925,6 @@ impl<T: GodotClass> Default for OnEditor<Gd<T>> {
     }
 }
 
-impl<T: GodotClass> GodotConvert for OnEditor<Gd<T>>
-where
-    Gd<T>: GodotConvert,
-    Option<<Gd<T> as GodotConvert>::Via>: GodotType,
-{
-    type Via = Option<<Gd<T> as GodotConvert>::Via>;
-}
-
-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(self)
-    }
-
-    fn set_property(&mut self, value: Self::Via) {
-        OnEditor::<Gd<T>>::set_property(self, value)
-    }
-}
-
-impl<T> Export for OnEditor<Gd<T>>
-where
-    T: GodotClass + Bounds<Exportable = bounds::Yes>,
-    OnEditor<Gd<T>>: Var,
-{
-    fn export_hint() -> PropertyHintInfo {
-        Gd::<T>::export_hint()
-    }
-
-    #[doc(hidden)]
-    fn as_node_class() -> Option<ClassName> {
-        Gd::<T>::as_node_class()
-    }
-}
-
 impl<T: GodotClass> PartialEq for Gd<T> {
     /// ⚠️ Returns whether two `Gd` pointers point to the same object.
     ///