Refactor meta-information types, fix more dangling pointers

Author: Bromeon

godot-codegen/src/central_generator.rs

@@ -124,7 +124,7 @@ fn make_sys_code(central_items: &CentralItems) -> String {
 
         impl VariantType {
             #[doc(hidden)]
-            pub fn from_ord(enumerator: crate::GDNativeVariantType) -> Self {
+            pub fn from_sys(enumerator: crate::GDNativeVariantType) -> Self {
                 // Annoying, but only stable alternative is transmute(), which dictates enum size
                 match enumerator {
                     0 => Self::Nil,
@@ -136,7 +136,7 @@ fn make_sys_code(central_items: &CentralItems) -> String {
             }
 
             #[doc(hidden)]
-            pub fn to_ord(self) -> crate::GDNativeVariantType {
+            pub fn sys(self) -> crate::GDNativeVariantType {
                 self as _
             }
         }
@@ -155,7 +155,7 @@ fn make_sys_code(central_items: &CentralItems) -> String {
 
         impl VariantOperator {
             #[doc(hidden)]
-            pub fn from_ord(enumerator: crate::GDNativeVariantOperator) -> Self {
+            pub fn from_sys(enumerator: crate::GDNativeVariantOperator) -> Self {
                 match enumerator {
                     #(
                         #variant_op_enumerators_ord => Self::#variant_op_enumerators_pascal,
@@ -165,7 +165,7 @@ fn make_sys_code(central_items: &CentralItems) -> String {
             }
 
             #[doc(hidden)]
-            pub fn to_ord(self) -> crate::GDNativeVariantOperator {
+            pub fn sys(self) -> crate::GDNativeVariantOperator {
                 self as _
             }
         }

godot-core/src/builtin/meta/class_name.rs

@@ -0,0 +1,48 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use godot_ffi as sys;
+
+use std::fmt::{Display, Formatter, Result as FmtResult};
+
+use crate::builtin::*;
+use crate::obj::GodotClass;
+
+/// Utility to construct class names known at compile time.
+/// Cannot be a function since the backing string must be retained.
+#[derive(Eq, PartialEq, Hash, Clone, Debug)]
+pub struct ClassName {
+    backing: StringName,
+}
+
+impl ClassName {
+    pub fn new<T: GodotClass>() -> Self {
+        Self {
+            backing: StringName::from(T::CLASS_NAME),
+        }
+    }
+
+    pub fn from_static(string: &'static str) -> Self {
+        Self {
+            backing: StringName::from(string),
+        }
+    }
+
+    pub fn string_sys(&self) -> sys::GDNativeStringNamePtr {
+        self.backing.string_sys()
+    }
+
+    #[must_use]
+    pub fn leak_string_name(self) -> sys::GDNativeStringNamePtr {
+        self.backing.leak_string_sys()
+    }
+}
+
+impl Display for ClassName {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        self.backing.fmt(f)
+    }
+}

godot-core/src/builtin/meta/mod.rs

@@ -0,0 +1,81 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+mod class_name;
+mod signature;
+
+pub use class_name::*;
+pub use signature::*;
+
+use crate::builtin::*;
+use crate::engine::global;
+
+use godot_ffi as sys;
+
+/// Stores meta-information about registered types or properties.
+///
+/// Filling this information properly is important so that Godot can use ptrcalls instead of varcalls
+/// (requires typed GDScript + sufficient information from the extension side)
+pub trait VariantMetadata {
+    fn variant_type() -> VariantType;
+
+    fn property_info(property_name: &str) -> PropertyInfo {
+        PropertyInfo::new(
+            Self::variant_type(),
+            ClassName::new::<()>(), // FIXME Option or so
+            StringName::from(property_name),
+        )
+    }
+
+    fn param_metadata() -> sys::GDNativeExtensionClassMethodArgumentMetadata {
+        sys::GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_NONE
+    }
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
+/// Rusty abstraction of sys::GDNativePropertyInfo
+/// Keeps the actual allocated values (the sys equivalent only keeps pointers, which fall out of scope)
+#[derive(Debug)]
+pub struct PropertyInfo {
+    variant_type: VariantType,
+    class_name: ClassName,
+    property_name: StringName,
+    hint: global::PropertyHint,
+    hint_string: GodotString,
+    usage: global::PropertyUsageFlags,
+}
+
+impl PropertyInfo {
+    pub fn new(
+        variant_type: VariantType,
+        class_name: ClassName,
+        property_name: StringName,
+    ) -> Self {
+        Self {
+            variant_type,
+            class_name,
+            property_name,
+            hint: global::PropertyHint::PROPERTY_HINT_NONE,
+            hint_string: GodotString::new(),
+            usage: global::PropertyUsageFlags::PROPERTY_USAGE_DEFAULT,
+        }
+    }
+
+    /// Converts to the FFI type. Keep this object allocated while using that!
+    pub fn sys(&self) -> sys::GDNativePropertyInfo {
+        use crate::obj::EngineEnum as _;
+
+        sys::GDNativePropertyInfo {
+            type_: self.variant_type.sys(),
+            name: self.property_name.string_sys(),
+            class_name: self.class_name.string_sys(),
+            hint: u32::try_from(self.hint.ord()).expect("hint.ord()"),
+            hint_string: self.hint_string.string_sys(),
+            usage: u32::try_from(self.usage.ord()).expect("usage.ord()"),
+        }
+    }
+}

godot-core/src/builtin/variant/variant_metadata.rs renamed to godot-core/src/builtin/meta/signature.rs

@@ -5,38 +5,16 @@
  */
 
 use godot_ffi as sys;
+use godot_ffi::VariantType;
 use std::fmt::Debug;
 
-pub trait VariantMetadata {
-    fn variant_type() -> sys::GDNativeVariantType;
-
-    fn property_info(property_name: &str) -> sys::GDNativePropertyInfo {
-        let property_name = StringName::from(property_name);
-
-        sys::GDNativePropertyInfo {
-            type_: Self::variant_type(),
-            name: property_name.leak_string_sys(),
-            class_name: std::ptr::null_mut(),
-            hint: 0,
-            hint_string: std::ptr::null_mut(),
-            usage: 7, // Default, TODO generate global enums
-        }
-    }
-
-    fn param_metadata() -> sys::GDNativeExtensionClassMethodArgumentMetadata {
-        sys::GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_NONE
-    }
-}
-
-// ----------------------------------------------------------------------------------------------------------------------------------------------
-
 pub trait SignatureTuple {
     type Params;
     type Ret;
 
-    fn variant_type(index: i32) -> sys::GDNativeVariantType;
+    fn variant_type(index: i32) -> VariantType;
+    fn property_info(index: i32, param_name: &str) -> PropertyInfo;
     fn param_metadata(index: i32) -> sys::GDNativeExtensionClassMethodArgumentMetadata;
-    fn property_info(index: i32, param_name: &str) -> sys::GDNativePropertyInfo;
 
     fn varcall<C: GodotClass>(
         instance_ptr: sys::GDExtensionClassInstancePtr,
@@ -74,7 +52,8 @@ pub trait SignatureTuple {
 //     }
 // }
 //
-use crate::builtin::{FromVariant, StringName, ToVariant, Variant};
+use crate::builtin::meta::*;
+use crate::builtin::{FromVariant, ToVariant, Variant};
 use crate::obj::GodotClass;
 
 macro_rules! impl_signature_for_tuple {
@@ -91,7 +70,7 @@ macro_rules! impl_signature_for_tuple {
             type Ret = $R;
 
             #[inline]
-            fn variant_type(index: i32) -> sys::GDNativeVariantType {
+            fn variant_type(index: i32) -> sys::VariantType {
                 match index {
                     -1 => $R::variant_type(),
                     $(
@@ -114,7 +93,7 @@ macro_rules! impl_signature_for_tuple {
             }
 
             #[inline]
-            fn property_info(index: i32, param_name: &str) -> sys::GDNativePropertyInfo {
+            fn property_info(index: i32, param_name: &str) -> PropertyInfo {
                 match index {
                     -1 => $R::property_info(param_name),
                     $(
@@ -208,34 +187,3 @@ impl_signature_for_tuple!(R, P0: 0, P1: 1, P2: 2, P3: 3, P4: 4, P5: 5, P6: 6);
 impl_signature_for_tuple!(R, P0: 0, P1: 1, P2: 2, P3: 3, P4: 4, P5: 5, P6: 6, P7: 7);
 impl_signature_for_tuple!(R, P0: 0, P1: 1, P2: 2, P3: 3, P4: 4, P5: 5, P6: 6, P7: 7, P8: 8);
 impl_signature_for_tuple!(R, P0: 0, P1: 1, P2: 2, P3: 3, P4: 4, P5: 5, P6: 6, P7: 7, P8: 8, P9: 9);
-
-// Re-exported to crate::private
-#[doc(hidden)]
-pub mod func_callbacks {
-    use super::*;
-
-    pub extern "C" fn get_type<S: SignatureTuple>(
-        _method_data: *mut std::ffi::c_void,
-        n: i32,
-    ) -> sys::GDNativeVariantType {
-        S::variant_type(n)
-    }
-
-    pub extern "C" fn get_info<S: SignatureTuple>(
-        _method_data: *mut std::ffi::c_void,
-        n: i32,
-        ret: *mut sys::GDNativePropertyInfo,
-    ) {
-        // Return value is the first "argument"
-        let info = S::property_info(n, "TODO");
-        unsafe { *ret = info };
-    }
-
-    pub extern "C" fn get_metadata<S: SignatureTuple>(
-        _method_data: *mut std::ffi::c_void,
-        n: i32,
-    ) -> sys::GDNativeExtensionClassMethodArgumentMetadata {
-        // Return value is the first "argument"
-        S::param_metadata(n)
-    }
-}

godot-core/src/builtin/mod.rs

@@ -18,6 +18,8 @@ mod vector2;
 mod vector3;
 mod vector4;
 
+pub mod meta;
+
 pub use arrays::*;
 pub use color::*;
 pub use others::*;

godot-core/src/builtin/string_name.rs

@@ -43,7 +43,7 @@ impl StringName {
 
         let boks = Box::new(self.clone());
         let ptr = boks.string_sys();
-        println!("Cloned: '{}' -> '{}'", self,&*boks);
+        println!("Cloned: '{}' -> '{}'", self, &*boks);
         Box::leak(boks);
 
         ptr

godot-core/src/builtin/variant/impls.rs

@@ -5,6 +5,7 @@
  */
 
 use super::*;
+use crate::builtin::meta::VariantMetadata;
 use crate::builtin::*;
 use godot_ffi as sys;
 use sys::GodotFfi;
@@ -59,8 +60,8 @@ macro_rules! impl_variant_traits {
         }
 
         impl VariantMetadata for $T {
-            fn variant_type() -> sys::GDNativeVariantType {
-                sys::$variant_type
+            fn variant_type() -> VariantType {
+                VariantType::$variant_type
             }
 
             $($extra)*
@@ -84,8 +85,8 @@ macro_rules! impl_variant_traits_int {
         }
 
         impl VariantMetadata for $T {
-            fn variant_type() -> sys::GDNativeVariantType {
-                sys::GDNATIVE_VARIANT_TYPE_INT
+            fn variant_type() -> VariantType {
+                VariantType::Int
             }
 
             fn param_metadata() -> sys::GDNativeExtensionClassMethodArgumentMetadata {
@@ -111,8 +112,8 @@ macro_rules! impl_variant_traits_float {
         }
 
         impl VariantMetadata for $T {
-            fn variant_type() -> sys::GDNativeVariantType {
-                sys::GDNATIVE_VARIANT_TYPE_FLOAT
+            fn variant_type() -> VariantType {
+                VariantType::Float
             }
 
             fn param_metadata() -> sys::GDNativeExtensionClassMethodArgumentMetadata {
@@ -129,30 +130,28 @@ macro_rules! impl_variant_traits_float {
 mod impls {
     use super::*;
 
-    impl_variant_traits!(bool, bool_to_variant, bool_from_variant, GDNATIVE_VARIANT_TYPE_BOOL);
-    impl_variant_traits!(Vector2, vector2_to_variant, vector2_from_variant, GDNATIVE_VARIANT_TYPE_VECTOR2);
-    impl_variant_traits!(Vector3, vector3_to_variant, vector3_from_variant, GDNATIVE_VARIANT_TYPE_VECTOR3);
-    impl_variant_traits!(Vector4, vector4_to_variant, vector4_from_variant, GDNATIVE_VARIANT_TYPE_VECTOR4);
-    impl_variant_traits!(Vector2i, vector2i_to_variant, vector2i_from_variant, GDNATIVE_VARIANT_TYPE_VECTOR2I);
-    impl_variant_traits!(Vector3i, vector3i_to_variant, vector3i_from_variant, GDNATIVE_VARIANT_TYPE_VECTOR3I);
-    impl_variant_traits!(Color, color_to_variant, color_from_variant, GDNATIVE_VARIANT_TYPE_COLOR);
-    impl_variant_traits!(GodotString, string_to_variant, string_from_variant, GDNATIVE_VARIANT_TYPE_STRING);
-    impl_variant_traits!(StringName, string_name_to_variant, string_name_from_variant, GDNATIVE_VARIANT_TYPE_STRING_NAME);
+    impl_variant_traits!(bool, bool_to_variant, bool_from_variant, Bool);
+    impl_variant_traits!(Vector2, vector2_to_variant, vector2_from_variant, Vector2);
+    impl_variant_traits!(Vector3, vector3_to_variant, vector3_from_variant, Vector3);
+    impl_variant_traits!(Vector4, vector4_to_variant, vector4_from_variant, Vector4);
+    impl_variant_traits!(Vector2i, vector2i_to_variant, vector2i_from_variant, Vector2i);
+    impl_variant_traits!(Vector3i, vector3i_to_variant, vector3i_from_variant, Vector3i);
+    impl_variant_traits!(Color, color_to_variant, color_from_variant, Color);
+    impl_variant_traits!(GodotString, string_to_variant, string_from_variant, String);
+    impl_variant_traits!(StringName, string_name_to_variant, string_name_from_variant, StringName);
 
 
-    impl_variant_traits!(i64, int_to_variant, int_from_variant, GDNATIVE_VARIANT_TYPE_INT,
-        GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT64);
+    impl_variant_traits!(i64, int_to_variant, int_from_variant, Int, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT64);
     impl_variant_traits_int!(i8, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT8);
     impl_variant_traits_int!(i16, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT16);
     impl_variant_traits_int!(i32, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_INT32);
 
     impl_variant_traits_int!(u8, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT8);
     impl_variant_traits_int!(u16, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT16);
     impl_variant_traits_int!(u32, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_INT_IS_UINT32);
-    // u64 is not supported, because it cannot be represented on GDScript side, and converting to i64 is error-prone.
+    // u64 is not supported, because it cannot be represented on GDScript side, and implicitly converting to i64 is error-prone.
 
-    impl_variant_traits!(f64, float_to_variant, float_from_variant, GDNATIVE_VARIANT_TYPE_FLOAT,
-        GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_DOUBLE);
+    impl_variant_traits!(f64, float_to_variant, float_from_variant, Float, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_DOUBLE);
     impl_variant_traits_float!(f32, GDNATIVE_EXTENSION_METHOD_ARGUMENT_METADATA_REAL_IS_FLOAT);
 }
 
@@ -167,8 +166,8 @@ impl ToVariant for () {
 }
 
 impl VariantMetadata for () {
-    fn variant_type() -> sys::GDNativeVariantType {
-        sys::GDNATIVE_VARIANT_TYPE_NIL
+    fn variant_type() -> VariantType {
+        VariantType::Nil
     }
 }
 
@@ -186,7 +185,7 @@ impl FromVariant for Variant {
 
 // Variant itself
 impl VariantMetadata for Variant {
-    fn variant_type() -> sys::GDNativeVariantType {
-        sys::GDNATIVE_VARIANT_TYPE_NIL
+    fn variant_type() -> VariantType {
+        VariantType::Nil // FIXME is this correct? what else to use? is this called at all?
     }
 }