- Make property template test check exports as well

- Fix some places where property info was misaligned
- Rename `ExportInfo` to `PropertyHintInfo` now that it's used in both export and property

Author: lilizoey

godot-core/src/builtin/array.rs

@@ -8,7 +8,7 @@ use godot_ffi as sys;
 
 use crate::builtin::*;
 use crate::obj::Share;
-use crate::property::{Export, ExportInfo, Property, TypeStringHint};
+use crate::property::{Export, Property, PropertyHintInfo, TypeStringHint};
 use std::fmt;
 use std::marker::PhantomData;
 use sys::{ffi_methods, interface_fn, GodotFfi};
@@ -700,26 +700,30 @@ impl<T: GodotType> Property for Array<T> {
     }
 
     #[cfg(since_api = "4.2")]
-    fn property_hint() -> ExportInfo {
-        ExportInfo {
+    fn property_hint() -> PropertyHintInfo {
+        if T::Ffi::variant_type() == VariantType::Nil {
+            return PropertyHintInfo::with_hint_none("");
+        }
+
+        PropertyHintInfo {
             hint: crate::engine::global::PropertyHint::PROPERTY_HINT_ARRAY_TYPE,
             hint_string: T::godot_type_name().into(),
         }
     }
 }
 
 impl<T: GodotType + TypeStringHint> Export for Array<T> {
-    fn default_export_info() -> ExportInfo {
-        ExportInfo {
+    fn default_export_info() -> PropertyHintInfo {
+        PropertyHintInfo {
             hint: crate::engine::global::PropertyHint::PROPERTY_HINT_TYPE_STRING,
             hint_string: T::type_string().into(),
         }
     }
 }
 
 impl Export for Array<Variant> {
-    fn default_export_info() -> ExportInfo {
-        ExportInfo::with_hint_none()
+    fn default_export_info() -> PropertyHintInfo {
+        PropertyHintInfo::with_hint_none("Array")
     }
 }
 

godot-core/src/builtin/dictionary.rs

@@ -9,7 +9,7 @@ use godot_ffi as sys;
 use crate::builtin::meta::{FromGodot, ToGodot};
 use crate::builtin::{inner, Variant};
 use crate::obj::Share;
-use crate::property::{Export, ExportInfo, Property, TypeStringHint};
+use crate::property::{Export, Property, PropertyHintInfo, TypeStringHint};
 use std::fmt;
 use std::marker::PhantomData;
 use std::ptr::addr_of_mut;
@@ -351,8 +351,8 @@ impl TypeStringHint for Dictionary {
 }
 
 impl Export for Dictionary {
-    fn default_export_info() -> ExportInfo {
-        ExportInfo::with_hint_none()
+    fn default_export_info() -> PropertyHintInfo {
+        PropertyHintInfo::with_hint_none("Dictionary")
     }
 }
 

godot-core/src/obj/gd.rs

@@ -16,7 +16,7 @@ use crate::builtin::meta::{FromGodot, GodotConvert, GodotType, ToGodot};
 use crate::builtin::{Callable, StringName};
 use crate::obj::{cap, dom, mem, EngineEnum, GdDerefTarget, GodotClass, Inherits, Share};
 use crate::obj::{GdMut, GdRef, InstanceId};
-use crate::property::{Export, ExportInfo, Property, TypeStringHint};
+use crate::property::{Export, Property, PropertyHintInfo, TypeStringHint};
 use crate::{callbacks, engine, out};
 
 use super::RawGd;
@@ -513,7 +513,7 @@ impl<T: GodotClass> Property for Gd<T> {
 }
 
 impl<T: GodotClass> Export for Gd<T> {
-    fn default_export_info() -> ExportInfo {
+    fn default_export_info() -> PropertyHintInfo {
         let hint = if T::inherits::<engine::Resource>() {
             engine::global::PropertyHint::PROPERTY_HINT_RESOURCE_TYPE
         } else if T::inherits::<engine::Node>() {
@@ -526,7 +526,7 @@ impl<T: GodotClass> Export for Gd<T> {
         // but doesn't seem to make a difference otherwise.
         let hint_string = T::class_name().to_godot_string();
 
-        ExportInfo { hint, hint_string }
+        PropertyHintInfo { hint, hint_string }
     }
 }
 

godot-core/src/property.rs

@@ -12,21 +12,22 @@ use crate::engine::global::PropertyHint;
 
 /// Trait implemented for types that can be used as `#[var]` fields. This creates a copy of the
 /// value, for some type-specific definition of "copy". For example, `Array`, `Dictionary` and `Gd` are
-/// returned via `Share::share()` instead of copying the actual data.
+/// returned by shared reference instead of copying the actual data.
 pub trait Property {
     type Intermediate;
 
-    fn property_hint() -> ExportInfo {
-        ExportInfo::with_hint_none()
-    }
     fn get_property(&self) -> Self::Intermediate;
     fn set_property(&mut self, value: Self::Intermediate);
+
+    fn property_hint() -> PropertyHintInfo {
+        PropertyHintInfo::with_hint_none("")
+    }
 }
 
 /// Trait implemented for types that can be used as `#[export]` fields.
 pub trait Export: Property {
     /// The export info to use for an exported field of this type, if no other export info is specified.
-    fn default_export_info() -> ExportInfo;
+    fn default_export_info() -> PropertyHintInfo;
 }
 
 /// Trait for types that can be represented as a type string for use with
@@ -77,7 +78,7 @@ impl<T> Export for Option<T>
 where
     T: Export + From<<T as Property>::Intermediate>,
 {
-    fn default_export_info() -> ExportInfo {
+    fn default_export_info() -> PropertyHintInfo {
         T::default_export_info()
     }
 }
@@ -87,18 +88,20 @@ where
 
 /// Info needed for godot to understand how to export a type to the editor.
 #[derive(Clone, Eq, PartialEq, Debug)]
-pub struct ExportInfo {
+pub struct PropertyHintInfo {
     pub hint: PropertyHint,
     pub hint_string: GodotString,
 }
 
-impl ExportInfo {
-    /// Create a new `ExportInfo` with a property hint of
+impl PropertyHintInfo {
+    /// Create a new `PropertyHintInfo` with a property hint of
     /// [`PROPERTY_HINT_NONE`](PropertyHint::PROPERTY_HINT_NONE).
-    pub fn with_hint_none() -> Self {
+    ///
+    /// Usually Godot expects this to be combined with a `hint_string` containing the name of the type.
+    pub fn with_hint_none<S: Into<GodotString>>(type_name: S) -> Self {
         Self {
             hint: PropertyHint::PROPERTY_HINT_NONE,
-            hint_string: GodotString::new(),
+            hint_string: type_name.into(),
         }
     }
 }
@@ -125,7 +128,7 @@ pub mod export_info_functions {
     use crate::builtin::GodotString;
     use crate::engine::global::PropertyHint;
 
-    use super::ExportInfo;
+    use super::PropertyHintInfo;
 
     /// Turn a list of variables into a comma separated string containing only the identifiers corresponding
     /// to a true boolean variable.
@@ -156,7 +159,7 @@ pub mod export_info_functions {
         radians: bool,
         degrees: bool,
         hide_slider: bool,
-    ) -> ExportInfo {
+    ) -> PropertyHintInfo {
         let min_max = format!("{},{}", min, max);
 
         let rest =
@@ -168,7 +171,7 @@ pub mod export_info_functions {
             format!("{min_max},{rest}")
         };
 
-        ExportInfo {
+        PropertyHintInfo {
             hint: PropertyHint::PROPERTY_HINT_RANGE,
             hint_string: hint_string.into(),
         }
@@ -217,64 +220,64 @@ pub mod export_info_functions {
 
     type EnumVariant = ExportValueWithKey<i64>;
 
-    pub fn export_enum<T>(variants: &[T]) -> ExportInfo
+    pub fn export_enum<T>(variants: &[T]) -> PropertyHintInfo
     where
         for<'a> &'a T: Into<EnumVariant>,
     {
         let hint_string: String = EnumVariant::slice_as_hint_string(variants);
 
-        ExportInfo {
+        PropertyHintInfo {
             hint: PropertyHint::PROPERTY_HINT_ENUM,
             hint_string: hint_string.into(),
         }
     }
 
-    pub fn export_exp_easing(attenuation: bool, positive_only: bool) -> ExportInfo {
+    pub fn export_exp_easing(attenuation: bool, positive_only: bool) -> PropertyHintInfo {
         let hint_string = comma_separate_boolean_idents!(attenuation, positive_only);
 
-        ExportInfo {
+        PropertyHintInfo {
             hint: PropertyHint::PROPERTY_HINT_EXP_EASING,
             hint_string: hint_string.into(),
         }
     }
 
     type BitFlag = ExportValueWithKey<u32>;
 
-    pub fn export_flags<T>(bits: &[T]) -> ExportInfo
+    pub fn export_flags<T>(bits: &[T]) -> PropertyHintInfo
     where
         for<'a> &'a T: Into<BitFlag>,
     {
         let hint_string = BitFlag::slice_as_hint_string(bits);
 
-        ExportInfo {
+        PropertyHintInfo {
             hint: PropertyHint::PROPERTY_HINT_FLAGS,
             hint_string: hint_string.into(),
         }
     }
 
-    pub fn export_file<S: AsRef<str>>(filter: S) -> ExportInfo {
+    pub fn export_file<S: AsRef<str>>(filter: S) -> PropertyHintInfo {
         export_file_inner(false, filter)
     }
 
-    pub fn export_global_file<S: AsRef<str>>(filter: S) -> ExportInfo {
+    pub fn export_global_file<S: AsRef<str>>(filter: S) -> PropertyHintInfo {
         export_file_inner(true, filter)
     }
 
-    pub fn export_file_inner<S: AsRef<str>>(global: bool, filter: S) -> ExportInfo {
+    pub fn export_file_inner<S: AsRef<str>>(global: bool, filter: S) -> PropertyHintInfo {
         let hint = if global {
-            PropertyHint::PROPERTY_HINT_FILE
-        } else {
             PropertyHint::PROPERTY_HINT_GLOBAL_FILE
+        } else {
+            PropertyHint::PROPERTY_HINT_FILE
         };
 
-        ExportInfo {
+        PropertyHintInfo {
             hint,
             hint_string: filter.as_ref().into(),
         }
     }
 
-    pub fn export_placeholder<S: AsRef<str>>(placeholder: S) -> ExportInfo {
-        ExportInfo {
+    pub fn export_placeholder<S: AsRef<str>>(placeholder: S) -> PropertyHintInfo {
+        PropertyHintInfo {
             hint: PropertyHint::PROPERTY_HINT_PLACEHOLDER_TEXT,
             hint_string: placeholder.as_ref().into(),
         }
@@ -285,8 +288,8 @@ pub mod export_info_functions {
             $( $function_name:ident => $property_hint:ident, )*
         ) => {
             $(
-                pub fn $function_name() -> ExportInfo {
-                    ExportInfo {
+                pub fn $function_name() -> PropertyHintInfo {
+                    PropertyHintInfo {
                         hint: PropertyHint::$property_hint,
                         hint_string: GodotString::new()
                     }
@@ -356,8 +359,8 @@ mod export_impls {
 
         (@export $Ty:ty) => {
             impl Export for $Ty {
-                fn default_export_info() -> ExportInfo {
-                    ExportInfo::with_hint_none()
+                fn default_export_info() -> PropertyHintInfo {
+                    PropertyHintInfo::with_hint_none(<$Ty as $crate::builtin::meta::GodotType>::godot_type_name())
                 }
             }
         };

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

@@ -25,7 +25,7 @@ pub enum FieldHint {
         hint_string: TokenStream,
     },
 
-    /// The hint and hint string are given by a token stream returning an `ExportInfo` struct.
+    /// The hint and hint string are given by a token stream returning an `PropertyHintInfo` struct.
     HintFromExportFunction(TokenStream),
 }
 
@@ -133,7 +133,7 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
             },
             FieldHint::HintFromExportFunction(expression) => quote! {
                 {
-                    let ::godot::bind::property::ExportInfo { hint, hint_string } = #expression;
+                    let ::godot::bind::property::PropertyHintInfo { hint, hint_string } = #expression;
                     (hint, hint_string)
                 }
             },

godot-macros/src/derive/derive_export.rs

@@ -65,8 +65,8 @@ pub fn derive_export(decl: Declaration) -> ParseResult<TokenStream2> {
     let out = quote! {
         #[allow(unused_parens)]
         impl godot::bind::property::Export for #name {
-            fn default_export_info() -> godot::bind::property::ExportInfo {
-                godot::bind::property::ExportInfo {
+            fn default_export_info() -> godot::bind::property::PropertyHintInfo {
+                godot::bind::property::PropertyHintInfo {
                     hint: godot::engine::global::PropertyHint::PROPERTY_HINT_ENUM,
                     hint_string: godot::prelude::GodotString::from(#hint_string),
                 }

itest/rust/src/object_tests/property_template_test.rs

@@ -399,10 +399,11 @@ struct PropertyTemplateRust {
     #[export(multiline)]
     export_multiline: GodotString,
     #[export(range = (0.0, 20.0))]
-    export_range_0_20: f64,
+    export_range_float_0_20: f64,
     // We're missing step currently.
     // #[export(range = (-10, 20 /* , 0.2 */))]
     // export_range_float_neg_10_20_02: f64,
+    // we can only export ranges of floats currently
     // #[export(range = (0, 100, 1, "or_greater", "or_less"))]
     // export_range_int_0_100_1_or_greater_or_less: int,
     #[export(exp_easing)]
@@ -454,7 +455,7 @@ fn property_template_test(ctx: &TestContext) {
             .unwrap()
             .to::<GodotString>()
             .to_string();
-        if name.starts_with("property_") {
+        if name.starts_with("property_") || name.starts_with("export_") {
             properties.insert(name, property);
         }
     }

itest/rust/src/object_tests/property_test.rs

@@ -5,7 +5,7 @@
  */
 
 use godot::{
-    bind::property::ExportInfo,
+    bind::property::PropertyHintInfo,
     engine::{
         global::{PropertyHint, PropertyUsageFlags},
         Texture,
@@ -172,8 +172,8 @@ impl Property for SomeCStyleEnum {
 }
 
 impl Export for SomeCStyleEnum {
-    fn default_export_info() -> ExportInfo {
-        ExportInfo {
+    fn default_export_info() -> PropertyHintInfo {
+        PropertyHintInfo {
             hint: PropertyHint::PROPERTY_HINT_ENUM,
             hint_string: "A,B,C".into(),
         }