Reduce code duplication around TypeStringHint::type_string()

Author: Bromeon

godot-core/src/builtin/array.rs

@@ -8,7 +8,7 @@
 use godot_ffi as sys;
 
 use crate::builtin::*;
-use crate::property::{Export, PropertyHintInfo, TypeStringHint, Var};
+use crate::property::{builtin_type_string, Export, PropertyHintInfo, TypeStringHint, Var};
 use std::fmt;
 use std::marker::PhantomData;
 use sys::{ffi_methods, interface_fn, GodotFfi};
@@ -834,11 +834,7 @@ impl<T: ArrayElement + TypeStringHint> TypeStringHint for Array<T> {
 
 impl TypeStringHint for VariantArray {
     fn type_string() -> String {
-        if sys::GdextBuild::since_api("4.3") {
-            format!("{}:", VariantType::Array as i32)
-        } else {
-            format!("{}:Array", VariantType::Array as i32)
-        }
+        builtin_type_string::<VariantArray>()
     }
 }
 

godot-core/src/builtin/dictionary.rs

@@ -9,12 +9,13 @@ use godot_ffi as sys;
 
 use crate::builtin::meta::{FromGodot, ToGodot};
 use crate::builtin::{inner, Variant, VariantArray};
-use crate::property::{Export, PropertyHintInfo, TypeStringHint, Var};
-use std::marker::PhantomData;
-use std::{fmt, ptr};
+use crate::property::{builtin_type_string, Export, PropertyHintInfo, TypeStringHint, Var};
 use sys::types::OpaqueDictionary;
 use sys::{ffi_methods, interface_fn, GodotFfi};
 
+use std::marker::PhantomData;
+use std::{fmt, ptr};
+
 use super::meta::impl_godot_as_self;
 
 /// Godot's `Dictionary` type.
@@ -330,11 +331,7 @@ impl Var for Dictionary {
 
 impl TypeStringHint for Dictionary {
     fn type_string() -> String {
-        if sys::GdextBuild::since_api("4.3") {
-            format!("{}:", sys::VariantType::Dictionary as i32)
-        } else {
-            format!("{}:Dictionary", sys::VariantType::Dictionary as i32)
-        }
+        builtin_type_string::<Dictionary>()
     }
 }
 

godot-core/src/builtin/packed_array.rs

@@ -481,15 +481,16 @@ macro_rules! impl_packed_array {
 
         impl $crate::property::Export for $PackedArray {
             fn default_export_info() -> $crate::property::PropertyHintInfo {
+                // In 4.3 Godot can (and does) use type hint strings for packed arrays, see https://github.com/godotengine/godot/pull/82952.
                 if sys::GdextBuild::since_api("4.3") {
-                    // In 4.3 Godot can (and does) use type hint strings for packed arrays.
-                    // https://github.com/godotengine/godot/pull/82952
                     $crate::property::PropertyHintInfo {
                         hint: $crate::engine::global::PropertyHint::TYPE_STRING,
                         hint_string: <$Element as $crate::property::TypeStringHint>::type_string().into(),
                     }
                 } else {
-                    $crate::property::PropertyHintInfo::with_hint_none(<$PackedArray as $crate::builtin::meta::GodotType>::godot_type_name())
+                    $crate::property::PropertyHintInfo::with_hint_none(
+                        <$PackedArray as $crate::builtin::meta::GodotType>::godot_type_name()
+                    )
                 }
             }
         }

godot-core/src/registry/property.rs

@@ -9,7 +9,7 @@
 
 use godot_ffi as sys;
 
-use crate::builtin::meta::{FromGodot, GodotConvert, ToGodot};
+use crate::builtin::meta::{FromGodot, GodotConvert, GodotType, ToGodot};
 use crate::builtin::GString;
 use crate::engine::global::PropertyHint;
 
@@ -336,7 +336,6 @@ pub mod export_info_functions {
 mod export_impls {
     use super::*;
     use crate::builtin::*;
-    use godot_ffi as sys;
 
     macro_rules! impl_property_by_godot_convert {
         ($Ty:ty, no_export) => {
@@ -373,15 +372,7 @@ mod export_impls {
         (@type_string_hint $Ty:ty) => {
             impl TypeStringHint for $Ty {
                 fn type_string() -> String {
-                    use sys::GodotFfi as _;
-                    let variant_type = <$Ty as $crate::builtin::meta::GodotType>::Ffi::variant_type();
-
-                    if sys::GdextBuild::since_api("4.3") {
-                        format!("{}:", variant_type as i32)
-                    } else {
-                        let type_name = <$Ty as $crate::builtin::meta::GodotType>::godot_type_name();
-                        format!("{}:{}", variant_type as i32, type_name)
-                    }
+                    builtin_type_string::<$Ty>()
                 }
             }
         }
@@ -467,3 +458,19 @@ mod export_impls {
 
     // impl_property_by_godot_convert!(Signal);
 }
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Crate-local utilities
+
+pub(crate) fn builtin_type_string<T: GodotType>() -> String {
+    use sys::GodotFfi as _;
+
+    let variant_type = T::Ffi::variant_type();
+
+    // 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())
+    } else {
+        format!("{}:{}", variant_type.sys(), T::godot_type_name())
+    }
+}

itest/rust/src/object_tests/property_template_test.rs

@@ -33,10 +33,10 @@ fn property_template_test(ctx: &TestContext) {
     for property in rust_properties.get_property_list().iter_shared() {
         let name = property.get("name").unwrap().to::<String>();
 
-        // The format of array-properties in Godot 4.2 changed. This doesn't seem to cause issues if we
-        // compile against 4.1 and provide the property in the format 4.1 expects but run it with Godot 4.2.
-        // However this test checks that our output matches that of Godot, and so would fail in this
-        // circumstance. So here for now, just ignore array properties when we compile for 4.1 but run in 4.2.
+        // The format of array properties in Godot 4.2 changed. This doesn't seem to cause issues if we
+        // compile against 4.1 and provide the property in the format 4.1 expects, but run it with Godot 4.2.
+        // However, this test checks that our output matches that of Godot, and so would fail in this circumstance.
+        // For now, just ignore array properties when we compile for 4.1 but run in 4.2.
         if GdextBuild::since_api("4.2")
             && cfg!(before_api = "4.2")
             && name.starts_with("property_array_")