Implement correct property hints for @export_file etc. on Array<GString> + PackedStringArray

Also cause error if another field type is used.

Author: Bromeon

godot-core/src/meta/property_info.rs

@@ -23,6 +23,13 @@ use godot_ffi::VariantType;
 /// Keeps the actual allocated values (the `sys` equivalent only keeps pointers, which fall out of scope).
 #[derive(Debug, Clone)]
 // Note: is not #[non_exhaustive], so adding fields is a breaking change. Mostly used internally at the moment though.
+// Note: There was an idea of a high-level representation of the following, but it's likely easier and more efficient to use introspection
+// APIs like `is_array_of_elem()`, unless there's a real user-facing need.
+// pub(crate) enum SimplePropertyType {
+//     Variant { ty: VariantType },
+//     Array { elem_ty: VariantType },
+//     Object { class_name: ClassName },
+// }
 pub struct PropertyInfo {
     /// Which type this property has.
     ///
@@ -134,6 +141,21 @@ impl PropertyInfo {
         }
     }
 
+    // ------------------------------------------------------------------------------------------------------------------------------------------
+    // Introspection API -- could be made public in the future
+
+    pub(crate) fn is_array_of_elem<T>(&self) -> bool
+    where
+        T: ArrayElement,
+    {
+        self.variant_type == VariantType::ARRAY
+            && self.hint_info.hint == PropertyHint::ARRAY_TYPE
+            && self.hint_info.hint_string == T::Via::godot_type_name().into()
+    }
+
+    // ------------------------------------------------------------------------------------------------------------------------------------------
+    // FFI conversion functions
+
     /// Converts to the FFI type. Keep this object allocated while using that!
     pub fn property_sys(&self) -> sys::GDExtensionPropertyInfo {
         use crate::obj::EngineBitfield as _;

godot-core/src/meta/traits.rs

@@ -118,6 +118,12 @@ pub trait GodotType: GodotConvert<Via = Self> + sealed::Sealed + Sized + 'static
         ))
     }
 
+    /// Returns a string representation of the Godot type name, as it is used in several property hint contexts.
+    ///
+    /// Examples:
+    /// - `MyClass` for objects
+    /// - `StringName`, `AABB` or `int` for builtins
+    /// - `Array` for arrays
     #[doc(hidden)]
     fn godot_type_name() -> String;
 
@@ -165,7 +171,9 @@ pub trait ArrayElement: ToGodot + FromGodot + sealed::Sealed + meta::ParamType {
     // Note: several indirections in ArrayElement and the global `element_*` functions go through `GodotConvert::Via`,
     // to not require Self: GodotType. What matters is how array elements map to Godot on the FFI level (GodotType trait).
 
-    /// Returns the representation of this type as a type string.
+    /// Returns the representation of this type as a type string, e.g. `"4:"` for string, or `"24:34/MyClass"` for objects.
+    ///
+    /// (`4` and `24` are variant type ords; `34` is `PropertyHint::NODE_TYPE` ord).
     ///
     /// Used for elements in arrays (the latter despite `ArrayElement` not having a direct relation).
     ///

godot-core/src/registry/property.rs

@@ -226,8 +226,10 @@ where
 pub mod export_info_functions {
     use crate::builtin::GString;
     use crate::global::PropertyHint;
-    use crate::meta::PropertyHintInfo;
+    use crate::meta::{GodotType, PropertyHintInfo, PropertyInfo};
+    use crate::obj::EngineEnum;
     use crate::registry::property::Export;
+    use godot_ffi::VariantType;
 
     /// Turn a list of variables into a comma separated string containing only the identifiers corresponding
     /// to a true boolean variable.
@@ -416,19 +418,67 @@ pub mod export_info_functions {
         is_global: bool,
         filter: impl AsRef<str>,
     ) -> PropertyHintInfo {
+        let field_ty = T::Via::property_info("");
         let filter = filter.as_ref();
         debug_assert!(is_file || filter.is_empty()); // Dir never has filter.
 
+        export_file_or_dir_inner(&field_ty, is_file, is_global, filter)
+    }
+
+    pub fn export_file_or_dir_inner(
+        field_ty: &PropertyInfo,
+        is_file: bool,
+        is_global: bool,
+        filter: &str,
+    ) -> PropertyHintInfo {
         let hint = match (is_file, is_global) {
             (true, true) => PropertyHint::GLOBAL_FILE,
             (true, false) => PropertyHint::FILE,
             (false, true) => PropertyHint::GLOBAL_DIR,
             (false, false) => PropertyHint::DIR,
         };
 
+        // Returned value depends on field type.
+        match field_ty.variant_type {
+            // GString field:
+            // { "type": 4, "hint": 13, "hint_string": "*.png" }
+            VariantType::STRING => PropertyHintInfo {
+                hint,
+                hint_string: GString::from(filter),
+            },
+
+            // Array<GString> or PackedStringArray field:
+            // { "type": 28, "hint": 23, "hint_string": "4/13:*.png" }
+            VariantType::PACKED_STRING_ARRAY => to_string_array_hint(hint, filter),
+            VariantType::ARRAY if field_ty.is_array_of_elem::<GString>() => {
+                to_string_array_hint(hint, filter)
+            }
+
+            _ => {
+                // E.g. `global_file`.
+                let attribute_name = hint.as_str().to_lowercase();
+
+                // TODO nicer error handling.
+                // Compile time may be difficult (at least without extra traits... maybe const fn?). But at least more context info, field name etc.
+                panic!(
+                    "#[export({attribute_name})] only supports GString, Array<String> or PackedStringArray field types\n\
+                    encountered: {field_ty:?}"
+                );
+            }
+        }
+    }
+
+    /// For `Array<GString>` and `PackedStringArray` fields using one of the `@export[_global]_{file|dir}` annotations.
+    ///
+    /// Formats: `"4/13:"`, `"4/15:*.png"`, ...
+    fn to_string_array_hint(hint: PropertyHint, filter: &str) -> PropertyHintInfo {
+        let variant_ord = VariantType::STRING.ord(); // "4"
+        let hint_ord = hint.ord();
+        let hint_string = format!("{variant_ord}/{hint_ord}");
+
         PropertyHintInfo {
-            hint,
-            hint_string: GString::from(filter),
+            hint: PropertyHint::TYPE_STRING,
+            hint_string: format!("{hint_string}:{filter}").into(),
         }
     }
 
@@ -603,9 +653,9 @@ pub(crate) fn builtin_type_string<T: GodotType>() -> String {
 
     // Godot 4.3 changed representation for type hints, see https://github.com/godotengine/godot/pull/90716.
     if sys::GdextBuild::since_api("4.3") {
-        format!("{}:", variant_type.sys())
+        format!("{}:", variant_type.ord())
     } else {
-        format!("{}:{}", variant_type.sys(), T::godot_type_name())
+        format!("{}:{}", variant_type.ord(), T::godot_type_name())
     }
 }
 

itest/rust/src/object_tests/property_template_test.rs

@@ -21,7 +21,7 @@ use crate::framework::TestContext;
 
 use crate::register_tests::gen_ffi::PropertyTestsRust;
 
-#[itest(focus)]
+#[itest]
 fn property_template_test(ctx: &TestContext) {
     let rust_properties = PropertyTestsRust::new_alloc();
     let gdscript_properties = ctx.property_tests.clone();
@@ -92,9 +92,9 @@ fn property_template_test(ctx: &TestContext) {
             errors.push(format!(
                 "mismatch in property {name}:\n  GDScript: {gdscript_prop:?}\n  Rust:     {rust_prop:?}"
             ));
-        } else {
-            println!("matching property {name}\n  GDScript: {gdscript_prop:?}\n  Rust:     {rust_prop:?}");
-        }
+        } /*else {
+              println!("matching property {name}\n  GDScript: {gdscript_prop:?}\n  Rust:     {rust_prop:?}");
+          }*/
     }
 
     assert!(