Merge pull request #841 from godot-rust/bugfix/export-node-only-in-node

 Validate that Nodes can only be exported from Node-derived classes

Author: Bromeon

godot-core/src/obj/gd.rs

@@ -16,7 +16,8 @@ use crate::builtin::{Callable, NodePath, StringName, Variant};
 use crate::global::PropertyHint;
 use crate::meta::error::{ConvertError, FromFfiError};
 use crate::meta::{
-    ArrayElement, CallContext, FromGodot, GodotConvert, GodotType, PropertyHintInfo, ToGodot,
+    ArrayElement, CallContext, ClassName, FromGodot, GodotConvert, GodotType, PropertyHintInfo,
+    ToGodot,
 };
 use crate::obj::{
     bounds, cap, Bounds, EngineEnum, GdDerefTarget, GdMut, GdRef, GodotClass, Inherits, InstanceId,
@@ -823,6 +824,11 @@ where
 
         PropertyHintInfo { hint, hint_string }
     }
+
+    #[doc(hidden)]
+    fn as_node_class() -> Option<ClassName> {
+        T::inherits::<classes::Node>().then(|| T::class_name())
+    }
 }
 
 // Trait impls Property, Export and TypeStringHint for Option<Gd<T>> are covered by blanket impl for Option<T>

godot-core/src/registry/godot_register_wrappers.rs

@@ -11,11 +11,34 @@ use crate::builtin::StringName;
 use crate::global::PropertyUsageFlags;
 use crate::meta::{ClassName, GodotConvert, GodotType, PropertyHintInfo, PropertyInfo};
 use crate::obj::GodotClass;
-use crate::registry::property::Var;
-use crate::sys;
+use crate::registry::property::{Export, Var};
+use crate::{classes, sys};
 use godot_ffi::GodotFfi;
 
-pub fn register_var_or_export<C: GodotClass, T: Var>(
+/// Same as [`register_var()`], but statically verifies the `Export` trait (again) and the fact that nodes can only be exported from nodes.
+pub fn register_export<C: GodotClass, T: Export>(
+    property_name: &str,
+    getter_name: &str,
+    setter_name: &str,
+    hint_info: PropertyHintInfo,
+    usage: PropertyUsageFlags,
+) {
+    // Note: if the user manually specifies `hint`, `hint_string` or `usage` keys, and thus is routed to `register_var()` instead,
+    // they can bypass this validation.
+    if !C::inherits::<classes::Node>() {
+        if let Some(class) = T::as_node_class() {
+            panic!(
+                "#[export] for Gd<{t}>: nodes can only be exported in Node-derived classes, but the current class is {c}.",
+                t = class,
+                c = C::class_name()
+            );
+        }
+    }
+
+    register_var::<C, T>(property_name, getter_name, setter_name, hint_info, usage);
+}
+
+pub fn register_var<C: GodotClass, T: Var>(
     property_name: &str,
     getter_name: &str,
     setter_name: &str,

godot-core/src/registry/property.rs

@@ -9,7 +9,7 @@
 
 use godot_ffi as sys;
 
-use crate::meta::{FromGodot, GodotConvert, GodotType, PropertyHintInfo, ToGodot};
+use crate::meta::{ClassName, FromGodot, GodotConvert, GodotType, PropertyHintInfo, ToGodot};
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Trait definitions
@@ -55,6 +55,14 @@ pub trait Export: Var {
     fn export_hint() -> PropertyHintInfo {
         <Self as Var>::var_hint()
     }
+
+    /// If this is a class inheriting `Node`, returns the `ClassName`; otherwise `None`.
+    ///
+    /// Only overridden for `Gd<T>`, to detect erroneous exports of `Node` inside a `Resource` class.
+    #[allow(clippy::wrong_self_convention)]
+    fn as_node_class() -> Option<ClassName> {
+        None
+    }
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------

godot-macros/src/class/data_models/property.rs

@@ -72,14 +72,19 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
             mut usage_flags,
         } = var;
 
-        let mut export_hint = None;
+        let export_hint;
+        let registration_fn;
 
         if let Some(export) = export {
-            export_hint = export.to_export_hint();
-
             if usage_flags.is_inferred() {
                 usage_flags = UsageFlags::InferredExport;
             }
+
+            export_hint = export.to_export_hint();
+            registration_fn = quote! { register_export };
+        } else {
+            export_hint = None;
+            registration_fn = quote! { register_var };
         }
 
         let usage_flags = match usage_flags {
@@ -140,7 +145,7 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
         );
 
         export_tokens.push(quote! {
-            ::godot::register::private::register_var_or_export::<#class_name, #field_type>(
+            ::godot::register::private::#registration_fn::<#class_name, #field_type>(
                 #field_name,
                 #getter_name,
                 #setter_name,