From e4b5316244a8c82fa055b4eb2d3bd0bf0a9db463 Mon Sep 17 00:00:00 2001
From: Lili Zoey Zyli <sayaks1@gmail.com>
Date: Fri, 31 May 2024 19:42:37 +0200
Subject: [PATCH 1/3] Cleanup bool conversions Cleanup script instance
 borrowing

---
 godot-core/src/obj/script.rs | 240 +++++++++++++++++------------------
 1 file changed, 115 insertions(+), 125 deletions(-)

diff --git a/godot-core/src/obj/script.rs b/godot-core/src/obj/script.rs
index 8d664bd11..b64460e91 100644
--- a/godot-core/src/obj/script.rs
+++ b/godot-core/src/obj/script.rs
@@ -21,10 +21,10 @@ use std::ops::{Deref, DerefMut};
 use std::sync::Mutex;
 
 #[cfg(not(feature = "experimental-threads"))]
-use godot_cell::panicking::{GdCell, MutGuard};
+use godot_cell::panicking::{GdCell, MutGuard, RefGuard};
 
 #[cfg(feature = "experimental-threads")]
-use godot_cell::blocking::{GdCell, MutGuard};
+use godot_cell::blocking::{GdCell, MutGuard, RefGuard};
 
 use crate::builtin::{GString, StringName, Variant, VariantType};
 use crate::classes::{Script, ScriptLanguage};
@@ -175,6 +175,39 @@ struct ScriptInstanceData<T: ScriptInstance> {
     base: Base<T::Base>,
 }
 
+impl<T: ScriptInstance> ScriptInstanceData<T> {
+    unsafe fn borrow_script_sys<'a>(p_instance: sys::GDExtensionScriptInstanceDataPtr) -> &'a Self {
+        &*(p_instance as *mut ScriptInstanceData<T>)
+    }
+
+    fn borrow(&self) -> RefGuard<'_, T> {
+        self.inner
+            .borrow()
+            .unwrap_or_else(|err| Self::borrow_panic(err))
+    }
+
+    fn borrow_mut(&self) -> MutGuard<'_, T> {
+        self.inner
+            .borrow_mut()
+            .unwrap_or_else(|err| Self::borrow_panic(err))
+    }
+
+    fn cell_ref(&self) -> &GdCell<T> {
+        &self.inner
+    }
+
+    fn borrow_panic(err: Box<dyn std::error::Error>) -> ! {
+        panic!(
+            "\
+                ScriptInstance borrow failed, already bound; T = {}.\n  \
+                Make sure to use `SiMut::base_mut()` when possible.\n  \
+                Details: {err}.\
+            ",
+            std::any::type_name::<T>(),
+        )
+    }
+}
+
 impl<T: ScriptInstance> Drop for ScriptInstanceData<T> {
     fn drop(&mut self) {
         // SAFETY: The ownership of ScriptInstanceData is transferred to Godot after its creation. The engine then calls
@@ -425,12 +458,6 @@ mod script_instance_info {
     use std::ffi::c_void;
     use std::mem::ManuallyDrop;
 
-    #[cfg(not(feature = "experimental-threads"))]
-    use godot_cell::panicking::{GdCell, RefGuard};
-
-    #[cfg(feature = "experimental-threads")]
-    use godot_cell::blocking::{GdCell, RefGuard};
-
     use crate::builtin::{GString, StringName, Variant};
     use crate::classes::ScriptLanguage;
     use crate::obj::Gd;
@@ -439,45 +466,12 @@ mod script_instance_info {
 
     use super::{ScriptInstance, ScriptInstanceData, SiMut};
 
-    fn borrow_panic<T: ScriptInstance, R>(err: Box<dyn std::error::Error>) -> R {
-        panic!(
-            "\
-                ScriptInstance borrow failed, already bound; T = {}.\n  \
-                Make sure to use `SiMut::base_mut()` when possible.\n  \
-                Details: {err}.\
-            ",
-            type_name::<T>(),
-        );
-    }
-
-    fn borrow_instance<T: ScriptInstance>(instance: &ScriptInstanceData<T>) -> RefGuard<'_, T> {
-        instance.inner.borrow().unwrap_or_else(borrow_panic::<T, _>)
-    }
-
-    fn borrow_instance_cell<T: ScriptInstance>(instance: &ScriptInstanceData<T>) -> &GdCell<T> {
-        &instance.inner
-    }
-
-    /// # Safety
-    ///
-    /// `p_instance` must be a valid pointer to a `ScriptInstanceData<T>` for the duration of `'a`.
-    /// This pointer must have been created by [super::create_script_instance] and transfered to Godot.
-    unsafe fn instance_data_as_script_instance<'a, T: ScriptInstance>(
-        p_instance: sys::GDExtensionScriptInstanceDataPtr,
-    ) -> &'a ScriptInstanceData<T> {
-        &*(p_instance as *mut ScriptInstanceData<T>)
-    }
-
-    fn transfer_bool_to_godot(value: bool) -> sys::GDExtensionBool {
+    const fn bool_into_sys(value: bool) -> sys::GDExtensionBool {
         value as sys::GDExtensionBool
     }
 
-    /// # Safety
-    ///
-    /// - We expect the engine to provide a valid variant pointer the return value can be moved into.
-    unsafe fn transfer_variant_to_godot(variant: Variant, return_ptr: sys::GDExtensionVariantPtr) {
-        variant.move_into_var_ptr(return_ptr)
-    }
+    const SYS_TRUE: sys::GDExtensionBool = bool_into_sys(true);
+    const SYS_FALSE: sys::GDExtensionBool = bool_into_sys(true);
 
     /// # Safety
     ///
@@ -557,18 +551,17 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::set", type_name::<T>());
 
         let result = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-            let cell = borrow_instance_cell(instance);
-            let mut guard = cell.borrow_mut().unwrap_or_else(borrow_panic::<T, _>);
+            let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
+            let mut guard = instance.borrow_mut();
 
-            let instance_guard = SiMut::new(cell, &mut guard, &instance.base);
+            let instance_guard = SiMut::new(instance.cell_ref(), &mut guard, &instance.base);
 
             ScriptInstance::set_property(instance_guard, name, value)
         })
         // Unwrapping to a default of false, to indicate that the assignment is not handled by the script.
         .unwrap_or_default();
 
-        transfer_bool_to_godot(result)
+        bool_into_sys(result)
     }
 
     /// # Safety
@@ -584,19 +577,18 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::get", type_name::<T>());
 
         let return_value = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).get_property(name.clone())
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .get_property(name)
         });
 
-        let result = match return_value {
-            Ok(return_value) => return_value
-                .map(|variant| transfer_variant_to_godot(variant, r_ret))
-                .is_some(),
-            Err(_) => false,
-        };
-
-        transfer_bool_to_godot(result)
+        match return_value {
+            Ok(Some(variant)) => {
+                variant.move_into_var_ptr(r_ret);
+                SYS_TRUE
+            }
+            _ => SYS_FALSE,
+        }
     }
 
     /// # Safety
@@ -610,9 +602,9 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::get_property_list", type_name::<T>());
 
         let (property_list, property_sys_list) = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            let property_list = borrow_instance(instance).get_property_list();
+            let property_list = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .get_property_list();
 
             let property_sys_list: Box<[_]> = property_list
                 .iter()
@@ -627,7 +619,7 @@ mod script_instance_info {
         let list_length = unsafe { &mut *r_count };
         let return_pointer = transfer_ptr_list_to_godot(property_sys_list, list_length);
 
-        let instance = instance_data_as_script_instance::<T>(p_instance);
+        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
         instance
             .property_list
             .lock()
@@ -648,9 +640,9 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::get_method_list", type_name::<T>());
 
         let (method_list, method_sys_list) = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            let method_list = borrow_instance(instance).get_method_list();
+            let method_list = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .get_method_list();
 
             let method_sys_list = method_list
                 .iter()
@@ -665,7 +657,7 @@ mod script_instance_info {
         let list_length = unsafe { &mut *r_count };
         let return_pointer = transfer_ptr_list_to_godot(method_sys_list, list_length);
 
-        let instance = instance_data_as_script_instance::<T>(p_instance);
+        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
 
         instance
             .method_list
@@ -684,7 +676,7 @@ mod script_instance_info {
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_prop_info: *const sys::GDExtensionPropertyInfo,
     ) {
-        let instance = instance_data_as_script_instance::<T>(p_instance);
+        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
 
         let vec = instance
             .property_list
@@ -719,18 +711,17 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::call", type_name::<T>());
 
         let result = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_self);
-            let cell = borrow_instance_cell(instance);
-            let mut guard = cell.borrow_mut().unwrap_or_else(borrow_panic::<T, _>);
+            let instance = ScriptInstanceData::<T>::borrow_script_sys(p_self);
+            let mut guard = instance.borrow_mut();
 
-            let instance_guard = SiMut::new(cell, &mut guard, &instance.base);
+            let instance_guard = SiMut::new(instance.cell_ref(), &mut guard, &instance.base);
 
             ScriptInstance::call(instance_guard, method.clone(), args)
         });
 
         match result {
-            Ok(Ok(ret)) => {
-                transfer_variant_to_godot(ret, r_return);
+            Ok(Ok(variant)) => {
+                variant.move_into_var_ptr(r_return);
                 (*r_error).error = sys::GDEXTENSION_CALL_OK;
             }
 
@@ -753,9 +744,10 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::get_script", type_name::<T>());
 
         let script = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).get_script().to_owned()
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .get_script()
+                .to_owned()
         });
 
         match script {
@@ -774,13 +766,13 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::is_placeholder", type_name::<T>());
 
         let is_placeholder = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).is_placeholder()
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .is_placeholder()
         })
         .unwrap_or_default();
 
-        transfer_bool_to_godot(is_placeholder)
+        bool_into_sys(is_placeholder)
     }
 
     /// # Safety
@@ -795,13 +787,13 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::has_method", type_name::<T>());
 
         let has_method = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).has_method(method.clone())
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .has_method(method)
         })
         .unwrap_or_default();
 
-        transfer_bool_to_godot(has_method)
+        bool_into_sys(has_method)
     }
 
     /// # Safety
@@ -812,7 +804,7 @@ mod script_instance_info {
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_method_info: *const sys::GDExtensionMethodInfo,
     ) {
-        let instance = instance_data_as_script_instance::<T>(p_instance);
+        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
 
         let vec = instance
             .method_list
@@ -856,16 +848,16 @@ mod script_instance_info {
         let name = StringName::new_from_string_sys(p_name);
 
         let result = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).get_property_type(name.clone())
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .get_property_type(name.clone())
         });
 
         if let Ok(result) = result {
-            *r_is_valid = transfer_bool_to_godot(true);
+            *r_is_valid = SYS_TRUE;
             result.sys()
         } else {
-            *r_is_valid = transfer_bool_to_godot(false);
+            *r_is_valid = SYS_FALSE;
             0
         }
     }
@@ -883,9 +875,9 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::to_string", type_name::<T>());
 
         let string = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).to_string()
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .to_string()
         })
         .ok();
 
@@ -893,7 +885,7 @@ mod script_instance_info {
             return;
         };
 
-        *r_is_valid = transfer_bool_to_godot(true);
+        *r_is_valid = SYS_TRUE;
         transfer_string_to_godot(string, r_str);
     }
 
@@ -916,9 +908,9 @@ mod script_instance_info {
         };
 
         let property_states = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).get_property_state()
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .get_property_state()
         })
         .unwrap_or_default();
 
@@ -936,9 +928,9 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::get_language", type_name::<T>());
 
         let language = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).get_language()
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .get_language()
         });
 
         if let Ok(language) = language {
@@ -972,13 +964,13 @@ mod script_instance_info {
         };
 
         let result = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).on_refcount_decremented()
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .on_refcount_decremented()
         })
         .unwrap_or(true);
 
-        transfer_bool_to_godot(result)
+        bool_into_sys(result)
     }
 
     /// # Safety
@@ -995,9 +987,9 @@ mod script_instance_info {
         };
 
         handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).on_refcount_incremented();
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .on_refcount_incremented();
         })
         .unwrap_or_default();
     }
@@ -1022,19 +1014,18 @@ mod script_instance_info {
         };
 
         let return_value = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-
-            borrow_instance(instance).property_get_fallback(name)
+            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+                .borrow()
+                .property_get_fallback(name)
         });
 
-        let result = match return_value {
-            Ok(return_value) => return_value
-                .map(|value| transfer_variant_to_godot(value, r_ret))
-                .is_some(),
-            Err(_) => false,
-        };
-
-        transfer_bool_to_godot(result)
+        match return_value {
+            Ok(Some(variant)) => {
+                variant.move_into_var_ptr(r_ret);
+                SYS_TRUE
+            }
+            _ => SYS_FALSE,
+        }
     }
 
     /// # Safety
@@ -1057,15 +1048,14 @@ mod script_instance_info {
         };
 
         let result = handle_panic(ctx, || {
-            let instance = instance_data_as_script_instance::<T>(p_instance);
-            let cell = borrow_instance_cell(instance);
-            let mut guard = cell.borrow_mut().unwrap_or_else(borrow_panic::<T, _>);
+            let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
+            let mut guard = instance.borrow_mut();
 
-            let instance_guard = SiMut::new(cell, &mut guard, &instance.base);
+            let instance_guard = SiMut::new(instance.cell_ref(), &mut guard, &instance.base);
             ScriptInstance::property_set_fallback(instance_guard, name, value)
         })
         .unwrap_or_default();
 
-        transfer_bool_to_godot(result)
+        bool_into_sys(result)
     }
 }

From 3e80962a0260d4315e8807467430a90c86272866 Mon Sep 17 00:00:00 2001
From: Lili Zoey Zyli <sayaks1@gmail.com>
Date: Sun, 2 Jun 2024 17:07:41 +0200
Subject: [PATCH 2/3] Add ptrlist container Add into/free owned_sys methods for
 MethodList

Remove helper functions that were just used in one place and which didnt really do much to improve readability
---
 godot-core/src/builtin/variant/mod.rs |  28 +++
 godot-core/src/meta/mod.rs            | 134 ++++++++++----
 godot-core/src/obj/script.rs          | 251 +++++++++++---------------
 3 files changed, 235 insertions(+), 178 deletions(-)

diff --git a/godot-core/src/builtin/variant/mod.rs b/godot-core/src/builtin/variant/mod.rs
index bcc61a877..52ca17a3c 100644
--- a/godot-core/src/builtin/variant/mod.rs
+++ b/godot-core/src/builtin/variant/mod.rs
@@ -374,6 +374,34 @@ impl Variant {
         // SAFETY: `variant_array` isn't null so it is safe to call `from_raw_parts_mut` on the pointer cast to `*mut Variant`.
         unsafe { std::slice::from_raw_parts_mut(variant_array, length) }
     }
+
+    /// Consumes self and turns it into a sys-ptr, should be used together with [`from_owned_var_sys`](Self::from_owned_var_sys).
+    ///
+    /// This will leak memory unless `from_owned_var_sys` is called on the returned pointer.
+    pub(crate) fn into_owned_var_sys(self) -> sys::GDExtensionVariantPtr {
+        sys::static_assert_eq_size_align!(Variant, sys::types::OpaqueVariant);
+
+        let leaked = Box::into_raw(Box::new(self));
+        leaked.cast()
+    }
+
+    /// Creates a `Variant` from a sys-ptr without incrementing the refcount.
+    ///
+    /// # Safety
+    ///
+    /// * Must only be used on a pointer returned from a call to [`into_owned_var_sys`](Self::into_owned_var_sys).
+    /// * Must not be called more than once on the same pointer.
+    #[deny(unsafe_op_in_unsafe_fn)]
+    pub(crate) unsafe fn from_owned_var_sys(ptr: sys::GDExtensionVariantPtr) -> Self {
+        sys::static_assert_eq_size_align!(Variant, sys::types::OpaqueVariant);
+
+        let ptr = ptr.cast::<Self>();
+
+        // SAFETY: `ptr` was returned from a call to `into_owned_var_sys`, which means it was created by a call to
+        // `Box::into_raw`, thus we can use `Box::from_raw` here. Additionally this is only called once on this pointer.
+        let boxed = unsafe { Box::from_raw(ptr) };
+        *boxed
+    }
 }
 
 impl ArrayElement for Variant {}
diff --git a/godot-core/src/meta/mod.rs b/godot-core/src/meta/mod.rs
index 410b0ef9f..8a2c063a0 100644
--- a/godot-core/src/meta/mod.rs
+++ b/godot-core/src/meta/mod.rs
@@ -241,50 +241,114 @@ pub struct MethodInfo {
 }
 
 impl MethodInfo {
-    /// Converts to the FFI type. Keep this object allocated while using that!
-    ///
-    /// The struct returned by this function contains pointers into the fields of `self`. `self` should therefore not be dropped while the
-    /// `sys::GDExtensionMethodInfo` is still in use.
-    ///
-    /// This function also leaks memory that has to be cleaned up by the caller once it is no longer used. Specifically the `arguments` and
-    /// `default_arguments` vectors have to be reconstructed from the pointer and length and then dropped/freed.
+    /// Consumes self and turns it into a `sys::GDExtensionMethodInfo`, should be used together with
+    /// [`free_owned_method_sys`](Self::free_owned_method_sys).
     ///
-    /// Each vector can be reconstructed with `Vec::from_raw_parts` since the pointers were created with `Vec::into_boxed_slice`, which
-    /// guarantees that the vector capacity and length are equal.
-    pub fn method_sys(&self) -> sys::GDExtensionMethodInfo {
+    /// This will leak memory unless used together with `free_owned_method_sys`.
+    pub fn into_owned_method_sys(self) -> sys::GDExtensionMethodInfo {
         use crate::obj::EngineBitfield as _;
 
-        let argument_count = self.arguments.len() as u32;
-        let argument_vec = self
-            .arguments
-            .iter()
-            .map(|arg| arg.property_sys())
-            .collect::<Vec<_>>()
-            .into_boxed_slice();
-
-        // SAFETY: dereferencing the new box pointer is fine as it is guaranteed to not be null
-        let arguments = unsafe { (*Box::into_raw(argument_vec)).as_mut_ptr() };
-
-        let default_argument_count = self.default_arguments.len() as u32;
-        let default_argument_vec = self
-            .default_arguments
-            .iter()
-            .map(|arg| sys::SysPtr::force_mut(arg.var_sys()))
-            .collect::<Vec<_>>()
-            .into_boxed_slice();
-
-        // SAFETY: dereferencing the new box pointer is fine as it is guaranteed to not be null
-        let default_arguments = unsafe { (*Box::into_raw(default_argument_vec)).as_mut_ptr() };
+        // Destructure self to ensure all fields are used.
+        let Self {
+            id,
+            method_name,
+            // TODO: Do we need this?
+            class_name: _class_name,
+            return_type,
+            arguments,
+            default_arguments,
+            flags,
+        } = self;
+
+        let argument_count: u32 = arguments
+            .len()
+            .try_into()
+            .expect("cannot have more than `u32::MAX` arguments");
+        let arguments = arguments
+            .into_iter()
+            .map(|arg| arg.into_owned_property_sys())
+            .collect::<Box<[_]>>();
+        let arguments = Box::leak(arguments).as_mut_ptr();
+
+        let default_argument_count: u32 = default_arguments
+            .len()
+            .try_into()
+            .expect("cannot have more than `u32::MAX` default arguments");
+        let default_argument = default_arguments
+            .into_iter()
+            .map(|arg| arg.into_owned_var_sys())
+            .collect::<Box<[_]>>();
+        let default_arguments = Box::leak(default_argument).as_mut_ptr();
 
         sys::GDExtensionMethodInfo {
-            id: self.id,
-            name: sys::SysPtr::force_mut(self.method_name.string_sys()),
-            return_value: self.return_type.property_sys(),
+            id,
+            name: method_name.into_owned_string_sys(),
+            return_value: return_type.into_owned_property_sys(),
             argument_count,
             arguments,
             default_argument_count,
             default_arguments,
-            flags: u32::try_from(self.flags.ord()).expect("flags should be valid"),
+            flags: flags.ord().try_into().expect("flags should be valid"),
         }
     }
+
+    /// Properly frees a `sys::GDExtensionMethodInfo` created by [`into_owned_method_sys`](Self::into_owned_method_sys).
+    ///
+    /// # Safety
+    ///
+    /// * Must only be used on a struct returned from a call to `into_owned_method_sys`, without modification.
+    /// * Must not be called more than once on a `sys::GDExtensionMethodInfo` struct.
+    #[deny(unsafe_op_in_unsafe_fn)]
+    pub unsafe fn free_owned_method_sys(info: sys::GDExtensionMethodInfo) {
+        // Destructure info to ensure all fields are used.
+        let sys::GDExtensionMethodInfo {
+            name,
+            return_value,
+            flags: _flags,
+            id: _id,
+            argument_count,
+            arguments,
+            default_argument_count,
+            default_arguments,
+        } = info;
+
+        // SAFETY: `name` and `return_value` were created from the appropriate method calls, and have not been freed before this.
+        unsafe {
+            let _name = StringName::from_owned_string_sys(name);
+            PropertyInfo::free_owned_property_sys(return_value);
+        }
+
+        // SAFETY: These pointers were both created from a call to `as_mut_ptr` on a slice. Additionally these pointer will not be accessed
+        // again after this function call.
+        let (arguments_slice, default_arguments_slice) = unsafe {
+            (
+                std::slice::from_raw_parts_mut(
+                    arguments,
+                    argument_count
+                        .try_into()
+                        .expect("gdext only supports targets where u32 <= usize"),
+                ),
+                std::slice::from_raw_parts_mut(
+                    default_arguments,
+                    default_argument_count
+                        .try_into()
+                        .expect("gdext only supports targets where u32 <= usize"),
+                ),
+            )
+        };
+
+        // SAFETY: We have exclusive ownership of these slices, and they were originally created from a call to `Box::leak`.
+        let (_arguments, default_arguments) = unsafe {
+            (
+                Box::from_raw(arguments_slice),
+                Box::from_raw(default_arguments_slice),
+            )
+        };
+
+        default_arguments.iter().for_each(|ptr| {
+            // SAFETY: These pointers were originally created from a call to `Variant::into_owner_var_sys`, and this method will not be
+            // called again on this pointer.
+            let _variant = unsafe { Variant::from_owned_var_sys(*ptr) };
+        });
+    }
 }
diff --git a/godot-core/src/obj/script.rs b/godot-core/src/obj/script.rs
index b64460e91..75e48dda4 100644
--- a/godot-core/src/obj/script.rs
+++ b/godot-core/src/obj/script.rs
@@ -15,10 +15,8 @@
 // Re-export guards.
 pub use crate::obj::guards::{ScriptBaseMut, ScriptBaseRef};
 
-use std::collections::HashMap;
 use std::ffi::c_void;
 use std::ops::{Deref, DerefMut};
-use std::sync::Mutex;
 
 #[cfg(not(feature = "experimental-threads"))]
 use godot_cell::panicking::{GdCell, MutGuard, RefGuard};
@@ -32,6 +30,8 @@ use crate::meta::{MethodInfo, PropertyInfo};
 use crate::obj::{Base, Gd, GodotClass};
 use crate::sys;
 
+use self::ptrlist_container::PtrlistContainer;
+
 /// Implement custom scripts that can be attached to objects in Godot.
 ///
 /// To use script instances, implement this trait for your own type.
@@ -170,8 +170,8 @@ type ScriptInstanceInfo = sys::GDExtensionScriptInstanceInfo2;
 struct ScriptInstanceData<T: ScriptInstance> {
     inner: GdCell<T>,
     script_instance_ptr: *mut ScriptInstanceInfo,
-    property_list: Mutex<HashMap<*const sys::GDExtensionPropertyInfo, Vec<PropertyInfo>>>,
-    method_list: Mutex<HashMap<*const sys::GDExtensionMethodInfo, Vec<MethodInfo>>>,
+    property_lists: PtrlistContainer<sys::GDExtensionPropertyInfo>,
+    method_lists: PtrlistContainer<sys::GDExtensionMethodInfo>,
     base: Base<T::Base>,
 }
 
@@ -283,8 +283,8 @@ pub unsafe fn create_script_instance<T: ScriptInstance>(
     let data = ScriptInstanceData {
         inner: GdCell::new(rust_instance),
         script_instance_ptr: instance_ptr,
-        property_list: Default::default(),
-        method_list: Default::default(),
+        property_lists: PtrlistContainer::new(),
+        method_lists: PtrlistContainer::new(),
         // SAFETY: The script instance is always freed before the base object is destroyed. The weak reference should therefore never be
         // accessed after it has been freed.
         base: unsafe { Base::from_gd(&for_object) },
@@ -453,14 +453,71 @@ impl<'a, T: ScriptInstance> DerefMut for SiMut<'a, T> {
     }
 }
 
+// Encapsulate PtrlistContainer to help ensure safety.
+mod ptrlist_container {
+    use std::collections::HashMap;
+    use std::sync::Mutex;
+
+    pub struct PtrlistContainer<T> {
+        list_lengths: Mutex<HashMap<*mut T, u32>>,
+    }
+
+    impl<T> PtrlistContainer<T> {
+        pub fn new() -> Self {
+            Self {
+                list_lengths: Mutex::new(HashMap::new()),
+            }
+        }
+
+        pub fn list_into_sys(&self, list: Vec<T>) -> (*const T, u32) {
+            let len: u32 = list
+                .len()
+                .try_into()
+                .expect("list must have length that fits in u32");
+            let ptr = Box::leak(list.into_boxed_slice()).as_mut_ptr();
+
+            let old_value = self.list_lengths.lock().unwrap().insert(ptr, len);
+            assert_eq!(
+                old_value, None,
+                "attempted to insert the same list twice, this is a bug"
+            );
+
+            (ptr as *const T, len)
+        }
+
+        /// # Safety
+        /// - `ptr` must have been returned from a call to `list_into_sys` on `self`.
+        /// - `ptr` must not have been used in a call to this function before.
+        /// - `ptr` must not have been mutated since the call to `list_into_sys`.
+        /// - `ptr` must not be accessed after calling this function.
+        #[deny(unsafe_op_in_unsafe_fn)]
+        pub unsafe fn list_from_sys(&self, ptr: *const T) -> Box<[T]> {
+            let ptr: *mut T = ptr as *mut T;
+            let len = self
+                .list_lengths
+                .lock()
+                .unwrap()
+                .remove(&ptr)
+                .expect("attempted to free list from wrong collection, this is a bug");
+            let len: usize = len
+                .try_into()
+                .expect("gdext only supports targets where u32 <= usize");
+
+            // SAFETY: `ptr` was created in `list_into_sys` from a slice of length `len`.
+            // And has not been mutated since.
+            let slice = unsafe { std::slice::from_raw_parts_mut(ptr, len) };
+
+            // SAFETY: This is the first call to this function, and the list will not be accessed again after this function call.
+            unsafe { Box::from_raw(slice) }
+        }
+    }
+}
+
 mod script_instance_info {
     use std::any::type_name;
     use std::ffi::c_void;
-    use std::mem::ManuallyDrop;
 
-    use crate::builtin::{GString, StringName, Variant};
-    use crate::classes::ScriptLanguage;
-    use crate::obj::Gd;
+    use crate::builtin::{StringName, Variant};
     use crate::private::handle_panic;
     use crate::sys;
 
@@ -473,69 +530,6 @@ mod script_instance_info {
     const SYS_TRUE: sys::GDExtensionBool = bool_into_sys(true);
     const SYS_FALSE: sys::GDExtensionBool = bool_into_sys(true);
 
-    /// # Safety
-    ///
-    /// - The returned `*const T` is guaranteed to point to a list that has an equal length and capacity.
-    fn transfer_ptr_list_to_godot<T>(ptr_list: Box<[T]>, list_length: &mut u32) -> *mut T {
-        *list_length = ptr_list.len() as u32;
-
-        let ptr = Box::into_raw(ptr_list);
-
-        // SAFETY: `ptr` was just created in the line above and should be safe to dereference.
-        unsafe { (*ptr).as_mut_ptr() }
-    }
-
-    /// The returned pointer's lifetime is equal to the lifetime of `script`
-    fn transfer_script_to_godot(script: &Gd<crate::classes::Script>) -> sys::GDExtensionObjectPtr {
-        script.obj_sys()
-    }
-
-    /// # Safety
-    ///
-    /// - `ptr` is expected to point to a list with both a length and capacity of `list_length`.
-    /// - The list pointer `ptr` must have been created with [`transfer_ptr_list_to_godot`].
-    unsafe fn transfer_ptr_list_from_godot<T>(ptr: *const T, list_length: usize) -> Vec<T> {
-        Vec::from_raw_parts(sys::force_mut_ptr(ptr), list_length, list_length)
-    }
-
-    /// # Safety
-    ///
-    /// - The engine has to provide a valid string return pointer.
-    unsafe fn transfer_string_to_godot(string: GString, return_ptr: sys::GDExtensionStringPtr) {
-        string.move_into_string_ptr(return_ptr);
-    }
-
-    /// # Safety
-    ///
-    /// - `userdata` has to be a valid pointer that upholds the invariants of `sys::GDExtensionScriptInstancePropertyStateAdd`.
-    unsafe fn transfer_property_state_to_godot(
-        propery_states: Vec<(StringName, Variant)>,
-        property_state_add: sys::GDExtensionScriptInstancePropertyStateAdd,
-        userdata: *mut c_void,
-    ) {
-        let Some(property_state_add) = property_state_add else {
-            return;
-        };
-
-        propery_states.into_iter().for_each(|(name, value)| {
-            let name = ManuallyDrop::new(name);
-            let value = ManuallyDrop::new(value);
-
-            // SAFETY: Godot expects a string name and a variant pointer for each property. After receiving the pointer, the engine is responsible
-            // for managing the memory behind those references.
-            unsafe { property_state_add(name.string_sys(), value.var_sys(), userdata) };
-        });
-    }
-
-    /// # Safety
-    ///
-    /// - `script_lang` must live for as long as the pointer may be dereferenced.
-    unsafe fn transfer_script_lang_to_godot(
-        script_lang: Gd<ScriptLanguage>,
-    ) -> sys::GDExtensionScriptLanguagePtr {
-        script_lang.obj_sys() as sys::GDExtensionScriptLanguagePtr
-    }
-
     /// # Safety
     ///
     /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
@@ -601,32 +595,27 @@ mod script_instance_info {
     ) -> *const sys::GDExtensionPropertyInfo {
         let ctx = || format!("error when calling {}::get_property_list", type_name::<T>());
 
-        let (property_list, property_sys_list) = handle_panic(ctx, || {
+        let property_list = handle_panic(ctx, || {
             let property_list = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
                 .borrow()
                 .get_property_list();
 
-            let property_sys_list: Box<[_]> = property_list
-                .iter()
-                .map(|prop| prop.property_sys())
-                .collect();
-
-            (property_list, property_sys_list)
+            property_list
+                .into_iter()
+                .map(|prop| prop.into_owned_property_sys())
+                .collect::<Vec<_>>()
         })
         .unwrap_or_default();
 
-        // SAFETY: list_length has to be a valid pointer to a u32.
-        let list_length = unsafe { &mut *r_count };
-        let return_pointer = transfer_ptr_list_to_godot(property_sys_list, list_length);
+        let (list_ptr, list_length) = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            .property_lists
+            .list_into_sys(property_list);
 
-        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
-        instance
-            .property_list
-            .lock()
-            .expect("Mutex should not be poisoned")
-            .insert(return_pointer, property_list);
+        unsafe {
+            *r_count = list_length;
+        }
 
-        return_pointer
+        list_ptr
     }
 
     /// # Safety
@@ -639,31 +628,27 @@ mod script_instance_info {
     ) -> *const sys::GDExtensionMethodInfo {
         let ctx = || format!("error when calling {}::get_method_list", type_name::<T>());
 
-        let (method_list, method_sys_list) = handle_panic(ctx, || {
+        let method_list = handle_panic(ctx, || {
             let method_list = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
                 .borrow()
                 .get_method_list();
 
-            let method_sys_list = method_list
-                .iter()
-                .map(|method| method.method_sys())
+            let method_list = method_list
+                .into_iter()
+                .map(|method| method.into_owned_method_sys())
                 .collect();
 
-            (method_list, method_sys_list)
+            method_list
         })
         .unwrap_or_default();
 
-        // SAFETY: list_length has to be a valid pointer to a u32.
-        let list_length = unsafe { &mut *r_count };
-        let return_pointer = transfer_ptr_list_to_godot(method_sys_list, list_length);
-
         let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
 
-        instance
-            .method_list
-            .lock()
-            .expect("mutex should not be poisoned")
-            .insert(return_pointer, method_list);
+        let (return_pointer, list_length) = instance.method_lists.list_into_sys(method_list);
+
+        unsafe {
+            *r_count = list_length;
+        }
 
         return_pointer
     }
@@ -678,17 +663,7 @@ mod script_instance_info {
     ) {
         let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
 
-        let vec = instance
-            .property_list
-            .lock()
-            .expect("mutex should not be poisoned")
-            .remove(&p_prop_info)
-            .expect("Godot is trying to free the property list, but none has been set");
-
-        // SAFETY: p_prop_info is expected to have been created by get_property_list_func
-        // and therefore should have the same length as before. get_propery_list_func
-        // also guarantees that both vector length and capacity are equal.
-        let _drop = transfer_ptr_list_from_godot(p_prop_info, vec.len());
+        let _drop = instance.property_lists.list_from_sys(p_prop_info);
     }
 
     /// # Safety
@@ -747,11 +722,11 @@ mod script_instance_info {
             ScriptInstanceData::<T>::borrow_script_sys(p_instance)
                 .borrow()
                 .get_script()
-                .to_owned()
+                .clone()
         });
 
         match script {
-            Ok(script) => transfer_script_to_godot(&script),
+            Ok(script) => script.obj_sys(),
             Err(_) => std::ptr::null_mut(),
         }
     }
@@ -806,27 +781,7 @@ mod script_instance_info {
     ) {
         let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
 
-        let vec = instance
-            .method_list
-            .lock()
-            .expect("method_list mutex should not be poisoned")
-            .remove(&p_method_info)
-            .expect("Godot is trying to free the method_list, but none has been set");
-
-        // SAFETY: p_method_info is expected to have been created by get_method_list_func and therefore should have the same length as before.
-        // get_method_list_func also guarantees that both vector length and capacity are equal.
-        let vec_sys = transfer_ptr_list_from_godot(p_method_info, vec.len());
-
-        vec_sys.into_iter().for_each(|method_info| {
-            transfer_ptr_list_from_godot(
-                method_info.arguments,
-                method_info.argument_count as usize,
-            );
-            transfer_ptr_list_from_godot(
-                method_info.default_arguments,
-                method_info.default_argument_count as usize,
-            );
-        })
+        let _drop = instance.method_lists.list_from_sys(p_method_info);
     }
 
     /// # Safety
@@ -886,7 +841,7 @@ mod script_instance_info {
         };
 
         *r_is_valid = SYS_TRUE;
-        transfer_string_to_godot(string, r_str);
+        string.move_into_string_ptr(r_str);
     }
 
     /// # Safety
@@ -914,7 +869,17 @@ mod script_instance_info {
         })
         .unwrap_or_default();
 
-        transfer_property_state_to_godot(property_states, property_state_add, userdata);
+        let Some(property_state_add) = property_state_add else {
+            return;
+        };
+
+        for (name, value) in property_states {
+            property_state_add(
+                name.into_owned_string_sys(),
+                value.into_owned_var_sys(),
+                userdata,
+            );
+        }
     }
 
     /// # Safety
@@ -934,9 +899,9 @@ mod script_instance_info {
         });
 
         if let Ok(language) = language {
-            transfer_script_lang_to_godot(language)
+            language.obj_sys().cast()
         } else {
-            std::ptr::null::<c_void>() as sys::GDExtensionScriptLanguagePtr
+            std::ptr::null_mut()
         }
     }
 
@@ -947,7 +912,7 @@ mod script_instance_info {
     pub(super) unsafe extern "C" fn free_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
     ) {
-        drop(Box::from_raw(p_instance as *mut ScriptInstanceData<T>));
+        drop(Box::from_raw(p_instance.cast::<ScriptInstanceData<T>>()));
     }
 
     /// # Safety

From 686b59dedb23c0a5f7d766243e666922205400ce Mon Sep 17 00:00:00 2001
From: Lili Zoey Zyli <sayaks1@gmail.com>
Date: Sun, 2 Jun 2024 18:32:21 +0200
Subject: [PATCH 3/3] Add `sys::conv` Add `#[deny(unsafe_op_in_unsafe_fn)]` to
 `script_instance_info` Use `sys::conv` bools Final touches

---
 godot-core/src/builtin/callable.rs            |   6 +-
 godot-core/src/builtin/string/string_name.rs  |   2 +-
 godot-core/src/meta/mod.rs                    |  68 ++--
 godot-core/src/obj/script.rs                  | 364 +++++++++++-------
 godot-core/src/registry/callbacks.rs          |  17 +-
 godot-core/src/registry/class.rs              |  12 +-
 godot-core/src/registry/constant.rs           |   2 +-
 godot-ffi/src/conv.rs                         |  65 ++++
 godot-ffi/src/lib.rs                          |   2 +
 itest/godot/ManualFfiTests.gd                 |  15 +-
 .../script/script_instance_tests.rs           |  38 +-
 11 files changed, 359 insertions(+), 232 deletions(-)
 create mode 100644 godot-ffi/src/conv.rs

diff --git a/godot-core/src/builtin/callable.rs b/godot-core/src/builtin/callable.rs
index ddfb5c930..277024a09 100644
--- a/godot-core/src/builtin/callable.rs
+++ b/godot-core/src/builtin/callable.rs
@@ -432,7 +432,7 @@ mod custom_callable {
         let a: &T = CallableUserdata::inner_from_raw(callable_userdata_a);
         let b: &T = CallableUserdata::inner_from_raw(callable_userdata_b);
 
-        (a == b) as sys::GDExtensionBool
+        sys::conv::bool_to_sys(a == b)
     }
 
     pub unsafe extern "C" fn rust_callable_to_string_display<T: fmt::Display>(
@@ -444,7 +444,7 @@ mod custom_callable {
         let s = crate::builtin::GString::from(c.to_string());
 
         s.move_into_string_ptr(r_out);
-        *r_is_valid = true as sys::GDExtensionBool;
+        *r_is_valid = sys::conv::SYS_TRUE;
     }
 
     pub unsafe extern "C" fn rust_callable_to_string_named<F>(
@@ -455,6 +455,6 @@ mod custom_callable {
         let w: &mut FnWrapper<F> = CallableUserdata::inner_from_raw(callable_userdata);
 
         w.name.clone().move_into_string_ptr(r_out);
-        *r_is_valid = true as sys::GDExtensionBool;
+        *r_is_valid = sys::conv::SYS_TRUE;
     }
 }
diff --git a/godot-core/src/builtin/string/string_name.rs b/godot-core/src/builtin/string/string_name.rs
index d33f83e6e..f49614051 100644
--- a/godot-core/src/builtin/string/string_name.rs
+++ b/godot-core/src/builtin/string/string_name.rs
@@ -317,7 +317,7 @@ impl From<&'static std::ffi::CStr> for StringName {
                 sys::interface_fn!(string_name_new_with_latin1_chars)(
                     ptr,
                     c_str.as_ptr(),
-                    true as sys::GDExtensionBool, // p_is_static
+                    sys::conv::SYS_TRUE, // p_is_static
                 )
             })
         };
diff --git a/godot-core/src/meta/mod.rs b/godot-core/src/meta/mod.rs
index 8a2c063a0..641688c0a 100644
--- a/godot-core/src/meta/mod.rs
+++ b/godot-core/src/meta/mod.rs
@@ -17,6 +17,7 @@ mod traits;
 pub mod error;
 pub use class_name::ClassName;
 pub use godot_convert::{FromGodot, GodotConvert, ToGodot};
+use sys::conv::u32_to_usize;
 pub use traits::{ArrayElement, GodotType};
 
 pub(crate) use crate::impl_godot_as_self;
@@ -312,43 +313,46 @@ impl MethodInfo {
             default_arguments,
         } = info;
 
-        // SAFETY: `name` and `return_value` were created from the appropriate method calls, and have not been freed before this.
-        unsafe {
-            let _name = StringName::from_owned_string_sys(name);
-            PropertyInfo::free_owned_property_sys(return_value);
-        }
+        // SAFETY: `name` is a pointer that was returned from `StringName::into_owned_string_sys`, and has not been freed before this.
+        let _name = unsafe { StringName::from_owned_string_sys(name) };
+
+        // SAFETY: `return_value` is a pointer that was returned from `PropertyInfo::into_owned_property_sys`, and has not been freed before
+        // this.
+        unsafe { PropertyInfo::free_owned_property_sys(return_value) };
+
+        // SAFETY:
+        // - `from_raw_parts_mut`: `arguments` comes from `as_mut_ptr()` on a mutable slice of length `argument_count`, and no other
+        //    accesses to the pointer happens for the lifetime of the slice.
+        // - `Box::from_raw`: The slice was returned from a call to `Box::leak`, and we have ownership of the value behind this pointer.
+        let arguments = unsafe {
+            let slice = std::slice::from_raw_parts_mut(arguments, u32_to_usize(argument_count));
 
-        // SAFETY: These pointers were both created from a call to `as_mut_ptr` on a slice. Additionally these pointer will not be accessed
-        // again after this function call.
-        let (arguments_slice, default_arguments_slice) = unsafe {
-            (
-                std::slice::from_raw_parts_mut(
-                    arguments,
-                    argument_count
-                        .try_into()
-                        .expect("gdext only supports targets where u32 <= usize"),
-                ),
-                std::slice::from_raw_parts_mut(
-                    default_arguments,
-                    default_argument_count
-                        .try_into()
-                        .expect("gdext only supports targets where u32 <= usize"),
-                ),
-            )
+            Box::from_raw(slice)
         };
 
-        // SAFETY: We have exclusive ownership of these slices, and they were originally created from a call to `Box::leak`.
-        let (_arguments, default_arguments) = unsafe {
-            (
-                Box::from_raw(arguments_slice),
-                Box::from_raw(default_arguments_slice),
-            )
+        for info in arguments.iter() {
+            // SAFETY: These infos were originally created from a call to `PropertyInfo::into_owned_property_sys`, and this method
+            // will not be called again on this pointer.
+            unsafe { PropertyInfo::free_owned_property_sys(*info) }
+        }
+
+        // SAFETY:
+        // - `from_raw_parts_mut`: `default_arguments` comes from `as_mut_ptr()` on a mutable slice of length `default_argument_count`, and no
+        //    other accesses to the pointer happens for the lifetime of the slice.
+        // - `Box::from_raw`: The slice was returned from a call to `Box::leak`, and we have ownership of the value behind this pointer.
+        let default_arguments = unsafe {
+            let slice = std::slice::from_raw_parts_mut(
+                default_arguments,
+                u32_to_usize(default_argument_count),
+            );
+
+            Box::from_raw(slice)
         };
 
-        default_arguments.iter().for_each(|ptr| {
-            // SAFETY: These pointers were originally created from a call to `Variant::into_owner_var_sys`, and this method will not be
+        for variant in default_arguments.iter() {
+            // SAFETY: These pointers were originally created from a call to `Variant::into_owned_var_sys`, and this method will not be
             // called again on this pointer.
-            let _variant = unsafe { Variant::from_owned_var_sys(*ptr) };
-        });
+            let _variant = unsafe { Variant::from_owned_var_sys(*variant) };
+        }
     }
 }
diff --git a/godot-core/src/obj/script.rs b/godot-core/src/obj/script.rs
index 75e48dda4..fb54459f2 100644
--- a/godot-core/src/obj/script.rs
+++ b/godot-core/src/obj/script.rs
@@ -30,7 +30,7 @@ use crate::meta::{MethodInfo, PropertyInfo};
 use crate::obj::{Base, Gd, GodotClass};
 use crate::sys;
 
-use self::ptrlist_container::PtrlistContainer;
+use self::bounded_ptr_list::BoundedPtrList;
 
 /// Implement custom scripts that can be attached to objects in Godot.
 ///
@@ -131,7 +131,7 @@ pub trait ScriptInstance: Sized {
 
     /// Lets the engine get a reference to the script this instance was created for.
     ///
-    /// This function has to return a reference, because Scripts are reference counted in Godot and it has to be guaranteed that the object is
+    /// This function has to return a reference, because Scripts are reference counted in Godot and it must be guaranteed that the object is
     /// not freed before the engine increased the reference count. (every time a `Gd<T>` which contains a reference counted object is dropped the
     /// reference count is decremented.)
     fn get_script(&self) -> &Gd<Script>;
@@ -170,14 +170,19 @@ type ScriptInstanceInfo = sys::GDExtensionScriptInstanceInfo2;
 struct ScriptInstanceData<T: ScriptInstance> {
     inner: GdCell<T>,
     script_instance_ptr: *mut ScriptInstanceInfo,
-    property_lists: PtrlistContainer<sys::GDExtensionPropertyInfo>,
-    method_lists: PtrlistContainer<sys::GDExtensionMethodInfo>,
+    property_lists: BoundedPtrList<sys::GDExtensionPropertyInfo>,
+    method_lists: BoundedPtrList<sys::GDExtensionMethodInfo>,
     base: Base<T::Base>,
 }
 
 impl<T: ScriptInstance> ScriptInstanceData<T> {
-    unsafe fn borrow_script_sys<'a>(p_instance: sys::GDExtensionScriptInstanceDataPtr) -> &'a Self {
-        &*(p_instance as *mut ScriptInstanceData<T>)
+    ///  Convert a `ScriptInstanceData` sys pointer to a reference with unbounded lifetime.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must point to a live `ScriptInstanceData<T>` for the duration of `'a`.
+    unsafe fn borrow_script_sys<'a>(ptr: sys::GDExtensionScriptInstanceDataPtr) -> &'a Self {
+        &*(ptr.cast::<ScriptInstanceData<T>>())
     }
 
     fn borrow(&self) -> RefGuard<'_, T> {
@@ -283,8 +288,8 @@ pub unsafe fn create_script_instance<T: ScriptInstance>(
     let data = ScriptInstanceData {
         inner: GdCell::new(rust_instance),
         script_instance_ptr: instance_ptr,
-        property_lists: PtrlistContainer::new(),
-        method_lists: PtrlistContainer::new(),
+        property_lists: BoundedPtrList::new(),
+        method_lists: BoundedPtrList::new(),
         // SAFETY: The script instance is always freed before the base object is destroyed. The weak reference should therefore never be
         // accessed after it has been freed.
         base: unsafe { Base::from_gd(&for_object) },
@@ -453,22 +458,30 @@ impl<'a, T: ScriptInstance> DerefMut for SiMut<'a, T> {
     }
 }
 
-// Encapsulate PtrlistContainer to help ensure safety.
-mod ptrlist_container {
+// Encapsulate BoundedPtrList to help ensure safety.
+mod bounded_ptr_list {
     use std::collections::HashMap;
     use std::sync::Mutex;
 
-    pub struct PtrlistContainer<T> {
+    use godot_ffi as sys;
+
+    /// Helper struct to store the lengths of lists so they can be properly freed.
+    ///
+    /// This uses the term `list` because it refers to property/method lists in gdextension.
+    pub struct BoundedPtrList<T> {
         list_lengths: Mutex<HashMap<*mut T, u32>>,
     }
 
-    impl<T> PtrlistContainer<T> {
+    impl<T> BoundedPtrList<T> {
         pub fn new() -> Self {
             Self {
                 list_lengths: Mutex::new(HashMap::new()),
             }
         }
 
+        /// Convert a list into a pointer + length pair. Should be used together with [`list_from_sys`](Self::list_from_sys).
+        ///
+        /// If `list_from_sys` is not called on this list then that will cause a memory leak.
         pub fn list_into_sys(&self, list: Vec<T>) -> (*const T, u32) {
             let len: u32 = list
                 .len()
@@ -482,9 +495,11 @@ mod ptrlist_container {
                 "attempted to insert the same list twice, this is a bug"
             );
 
-            (ptr as *const T, len)
+            (ptr.cast_const(), len)
         }
 
+        /// Get a list back from a previous call to [`list_into_sys`](Self::list_into_sys).
+        ///
         /// # Safety
         /// - `ptr` must have been returned from a call to `list_into_sys` on `self`.
         /// - `ptr` must not have been used in a call to this function before.
@@ -492,16 +507,14 @@ mod ptrlist_container {
         /// - `ptr` must not be accessed after calling this function.
         #[deny(unsafe_op_in_unsafe_fn)]
         pub unsafe fn list_from_sys(&self, ptr: *const T) -> Box<[T]> {
-            let ptr: *mut T = ptr as *mut T;
+            let ptr: *mut T = ptr.cast_mut();
             let len = self
                 .list_lengths
                 .lock()
                 .unwrap()
                 .remove(&ptr)
                 .expect("attempted to free list from wrong collection, this is a bug");
-            let len: usize = len
-                .try_into()
-                .expect("gdext only supports targets where u32 <= usize");
+            let len: usize = sys::conv::u32_to_usize(len);
 
             // SAFETY: `ptr` was created in `list_into_sys` from a slice of length `len`.
             // And has not been mutated since.
@@ -513,39 +526,40 @@ mod ptrlist_container {
     }
 }
 
+#[deny(unsafe_op_in_unsafe_fn)]
 mod script_instance_info {
     use std::any::type_name;
     use std::ffi::c_void;
 
+    use crate::builtin::meta::{MethodInfo, PropertyInfo};
     use crate::builtin::{StringName, Variant};
     use crate::private::handle_panic;
     use crate::sys;
 
     use super::{ScriptInstance, ScriptInstanceData, SiMut};
-
-    const fn bool_into_sys(value: bool) -> sys::GDExtensionBool {
-        value as sys::GDExtensionBool
-    }
-
-    const SYS_TRUE: sys::GDExtensionBool = bool_into_sys(true);
-    const SYS_FALSE: sys::GDExtensionBool = bool_into_sys(true);
+    use sys::conv::{bool_to_sys, SYS_FALSE, SYS_TRUE};
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `p_name` has to be a valid pointer to a StringName.
-    /// - `p_value` has to be a valid pointer to a Variant.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_name` must be a valid [`StringName`] pointer.
+    /// - `p_value` must be a valid [`Variant`] pointer.
     pub(super) unsafe extern "C" fn set_property_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_name: sys::GDExtensionConstStringNamePtr,
         p_value: sys::GDExtensionConstVariantPtr,
     ) -> sys::GDExtensionBool {
-        let name = StringName::new_from_string_sys(p_name);
-        let value = Variant::borrow_var_sys(p_value);
+        let (name, value);
+        // SAFETY: `p_name` and `p_value` are valid pointers to a `StringName` and `Variant`.
+        unsafe {
+            name = StringName::new_from_string_sys(p_name);
+            value = Variant::borrow_var_sys(p_value);
+        }
         let ctx = || format!("error when calling {}::set", type_name::<T>());
 
         let result = handle_panic(ctx, || {
-            let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            let instance = unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) };
             let mut guard = instance.borrow_mut();
 
             let instance_guard = SiMut::new(instance.cell_ref(), &mut guard, &instance.base);
@@ -555,30 +569,34 @@ mod script_instance_info {
         // Unwrapping to a default of false, to indicate that the assignment is not handled by the script.
         .unwrap_or_default();
 
-        bool_into_sys(result)
+        bool_to_sys(result)
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `r_ret` will be a valid owned variant pointer after this call.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_name` must be a valid [`StringName`] pointer.
+    /// - It must be safe to move a `Variant` into `r_ret`.
     pub(super) unsafe extern "C" fn get_property_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_name: sys::GDExtensionConstStringNamePtr,
         r_ret: sys::GDExtensionVariantPtr,
     ) -> sys::GDExtensionBool {
-        let name = StringName::new_from_string_sys(p_name);
+        // SAFETY: `p_name` is a valid [`StringName`] pointer.
+        let name = unsafe { StringName::new_from_string_sys(p_name) };
         let ctx = || format!("error when calling {}::get", type_name::<T>());
 
         let return_value = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .get_property(name)
         });
 
         match return_value {
             Ok(Some(variant)) => {
-                variant.move_into_var_ptr(r_ret);
+                // SAFETY: It is safe to move a `Variant` into `r_ret`.
+                unsafe { variant.move_into_var_ptr(r_ret) };
                 SYS_TRUE
             }
             _ => SYS_FALSE,
@@ -587,18 +605,22 @@ mod script_instance_info {
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `r_count` is expected to be a valid pointer to an u32.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - It must be safe to assign a `u32` to `r_count`.
     pub(super) unsafe extern "C" fn get_property_list_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         r_count: *mut u32,
     ) -> *const sys::GDExtensionPropertyInfo {
         let ctx = || format!("error when calling {}::get_property_list", type_name::<T>());
 
+        // Encapsulate this unsafe block to avoid repeating the safety comment.
+        // SAFETY: This closure is only used in this function, and we may dereference `p_instance` to an immutable reference for the duration of
+        // this call.
+        let borrow_instance =
+            move || unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) };
+
         let property_list = handle_panic(ctx, || {
-            let property_list = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
-                .borrow()
-                .get_property_list();
+            let property_list = borrow_instance().borrow().get_property_list();
 
             property_list
                 .into_iter()
@@ -607,10 +629,11 @@ mod script_instance_info {
         })
         .unwrap_or_default();
 
-        let (list_ptr, list_length) = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+        let (list_ptr, list_length) = borrow_instance()
             .property_lists
             .list_into_sys(property_list);
 
+        // SAFETY: It is safe to assign a `u32` to `r_count`.
         unsafe {
             *r_count = list_length;
         }
@@ -620,7 +643,7 @@ mod script_instance_info {
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
     /// - `r_count` is expected to be a valid pointer to an u32.
     pub(super) unsafe extern "C" fn get_method_list_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
@@ -628,23 +651,24 @@ mod script_instance_info {
     ) -> *const sys::GDExtensionMethodInfo {
         let ctx = || format!("error when calling {}::get_method_list", type_name::<T>());
 
+        // Encapsulate this unsafe block to avoid repeating the safety comment.
+        // SAFETY: This closure is only used in this function, and we may dereference `p_instance` to an immutable reference for the duration of
+        // this call.
+        let borrow_instance =
+            move || unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) };
+
         let method_list = handle_panic(ctx, || {
-            let method_list = ScriptInstanceData::<T>::borrow_script_sys(p_instance)
-                .borrow()
-                .get_method_list();
+            let method_list = borrow_instance().borrow().get_method_list();
 
-            let method_list = method_list
+            method_list
                 .into_iter()
                 .map(|method| method.into_owned_method_sys())
-                .collect();
-
-            method_list
+                .collect()
         })
         .unwrap_or_default();
 
-        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
-
-        let (return_pointer, list_length) = instance.method_lists.list_into_sys(method_list);
+        let (return_pointer, list_length) =
+            borrow_instance().method_lists.list_into_sys(method_list);
 
         unsafe {
             *r_count = list_length;
@@ -655,24 +679,36 @@ mod script_instance_info {
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - The length of `p_prop_info` list is expected to not have changed since it was transferred to the engine.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_prop_info` must have been returned from a call to [`get_property_list_func`] called with the same `p_instance` pointer.
+    /// - `p_prop_info` must not have been mutated since the call to `get_property_list_func`.
     pub(super) unsafe extern "C" fn free_property_list_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_prop_info: *const sys::GDExtensionPropertyInfo,
     ) {
-        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
+        // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+        let instance = unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) };
+
+        // SAFETY: `p_prop_info` was returned from a call to `list_into_sys`, and has not been mutated since. This is also the first call
+        // to `list_from_sys` with this pointer.
+        let property_infos = unsafe { instance.property_lists.list_from_sys(p_prop_info) };
 
-        let _drop = instance.property_lists.list_from_sys(p_prop_info);
+        for info in property_infos.iter() {
+            // SAFETY: `info` was returned from a call to `into_owned_property_sys` and this is the first and only time this function is called
+            // on it.
+            unsafe { PropertyInfo::free_owned_property_sys(*info) };
+        }
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `p_method` has to be a valid Godot string name ptr.
+    /// - `p_self` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_method` must be a valid [`StringName`] pointer.
     /// - `p_args` has to point to a list of Variant pointers of length `p_argument_count`.
-    /// - `r_return` has to be a valid variant pointer into which the return value can be moved.
-    /// - `r_error` has to point to a valid [`GDExtenstionCallError`] which can be modified to reflect the outcome of the method call.
+    /// - All the variant pointers in `p_args`, as well the `p_args` pointer itself must be dereferenceable to an immutable reference for the
+    ///   duration of this call.
+    /// - It must be safe to move a [`Variant`] into `r_return`.
+    /// - `r_error` must point to an initialized [`sys::GDExtensionCallError`] which can be written to.
     pub(super) unsafe extern "C" fn call_func<T: ScriptInstance>(
         p_self: sys::GDExtensionScriptInstanceDataPtr,
         p_method: sys::GDExtensionConstStringNamePtr,
@@ -681,12 +717,22 @@ mod script_instance_info {
         r_return: sys::GDExtensionVariantPtr,
         r_error: *mut sys::GDExtensionCallError,
     ) {
-        let method = StringName::new_from_string_sys(p_method);
-        let args = Variant::borrow_ref_slice(p_args, p_argument_count as usize);
+        // SAFETY: `p_method` is a valid [`StringName`] pointer.
+        let method = unsafe { StringName::new_from_string_sys(p_method) };
+        // SAFETY: `p_args` is a valid array of length `p_argument_count`
+        let args = unsafe {
+            Variant::borrow_ref_slice(
+                p_args,
+                p_argument_count
+                    .try_into()
+                    .expect("argument count should be a valid `u32`"),
+            )
+        };
         let ctx = || format!("error when calling {}::call", type_name::<T>());
 
         let result = handle_panic(ctx, || {
-            let instance = ScriptInstanceData::<T>::borrow_script_sys(p_self);
+            // SAFETY: `p_self` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            let instance = unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_self) };
             let mut guard = instance.borrow_mut();
 
             let instance_guard = SiMut::new(instance.cell_ref(), &mut guard, &instance.base);
@@ -694,32 +740,36 @@ mod script_instance_info {
             ScriptInstance::call(instance_guard, method.clone(), args)
         });
 
-        match result {
+        let error = match result {
             Ok(Ok(variant)) => {
-                variant.move_into_var_ptr(r_return);
-                (*r_error).error = sys::GDEXTENSION_CALL_OK;
+                // SAFETY: It is safe to move a `Variant` into `r_return`.
+                unsafe { variant.move_into_var_ptr(r_return) };
+                sys::GDEXTENSION_CALL_OK
             }
 
-            Ok(Err(err)) => (*r_error).error = err,
+            Ok(Err(err)) => err,
 
-            Err(_) => {
-                (*r_error).error = sys::GDEXTENSION_CALL_ERROR_INVALID_METHOD;
-            }
+            Err(_) => sys::GDEXTENSION_CALL_ERROR_INVALID_METHOD,
         };
+
+        // SAFETY: `r_error` is an initialized pointer which we can write to.
+        unsafe { (*r_error).error = error };
     }
 
+    /// Ownership of the returned object is not transferred to the caller. The caller is therefore responsible for incrementing the reference
+    /// count.
+    ///
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - A pointer to a `Script` reference will be returned. The caller is then responsible for freeing the reference, including the adjustment
-    ///   of the reference count.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
     pub(super) unsafe extern "C" fn get_script_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
     ) -> sys::GDExtensionObjectPtr {
         let ctx = || format!("error when calling {}::get_script", type_name::<T>());
 
         let script = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .get_script()
                 .clone()
@@ -733,62 +783,74 @@ mod script_instance_info {
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - The boolean result is returned as an GDExtensionBool.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
     pub(super) unsafe extern "C" fn is_placeholder_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
     ) -> sys::GDExtensionBool {
         let ctx = || format!("error when calling {}::is_placeholder", type_name::<T>());
 
         let is_placeholder = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .is_placeholder()
         })
         .unwrap_or_default();
 
-        bool_into_sys(is_placeholder)
+        bool_to_sys(is_placeholder)
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `p_method` has to point to a valid string name.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_method` has to point to a valid `StringName`.
     pub(super) unsafe extern "C" fn has_method_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_method: sys::GDExtensionConstStringNamePtr,
     ) -> sys::GDExtensionBool {
-        let method = StringName::new_from_string_sys(p_method);
+        // SAFETY: `p_method` is a valid [`StringName`] pointer.
+        let method = unsafe { StringName::new_from_string_sys(p_method) };
         let ctx = || format!("error when calling {}::has_method", type_name::<T>());
 
         let has_method = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .has_method(method)
         })
         .unwrap_or_default();
 
-        bool_into_sys(has_method)
+        bool_to_sys(has_method)
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - The length of `p_method_info` list is expected to not have changed since it was transferred to the engine.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_method_info` must have been returned from a call to [`get_method_list_func`] called with the same `p_instance` pointer.
+    /// - `p_method_info` must not have been mutated since the call to `get_method_list_func`.
     pub(super) unsafe extern "C" fn free_method_list_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_method_info: *const sys::GDExtensionMethodInfo,
     ) {
-        let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
+        // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+        let instance = unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) };
 
-        let _drop = instance.method_lists.list_from_sys(p_method_info);
+        // SAFETY: `p_method_info` was returned from a call to `list_into_sys`, and has not been mutated since. This is also the first call
+        // to `list_from_sys` with this pointer.
+        let method_infos = unsafe { instance.method_lists.list_from_sys(p_method_info) };
+
+        for info in method_infos.iter() {
+            // SAFETY: `info` was returned from a call to `into_owned_method_sys`, and this is the first and only time we call this method on
+            // it.
+            unsafe { MethodInfo::free_owned_method_sys(*info) };
+        }
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `p_name` is expected to be a valid ptr to a Godot string name.
-    /// - `r_is_valid` is expected to be a valid ptr to a [`GDExtensionBool`] which can be modified to reflect the validity of the return value.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_name` must be a valid [`StringName`] pointer.
+    /// - `r_is_valid` must be assignable.
     pub(super) unsafe extern "C" fn get_property_type_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_name: sys::GDExtensionConstStringNamePtr,
@@ -800,28 +862,32 @@ mod script_instance_info {
                 type_name::<T>()
             )
         };
-        let name = StringName::new_from_string_sys(p_name);
+        // SAFETY: `p_name` is a valid [`StringName`] pointer.
+        let name = unsafe { StringName::new_from_string_sys(p_name) };
 
         let result = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .get_property_type(name.clone())
         });
 
-        if let Ok(result) = result {
-            *r_is_valid = SYS_TRUE;
-            result.sys()
+        let (is_valid, result) = if let Ok(result) = result {
+            (SYS_TRUE, result.sys())
         } else {
-            *r_is_valid = SYS_FALSE;
-            0
-        }
+            (SYS_FALSE, sys::GDEXTENSION_VARIANT_TYPE_NIL)
+        };
+
+        // SAFETY: `r_is_valid` is assignable.
+        unsafe { *r_is_valid = is_valid };
+        result
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `r_is_valid` is expected to be a valid `GDExtensionBool` ptr which can be modified to reflect the validity of the return value.
-    /// - `r_str` is expected to be a string pointer into which the return value can be moved.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `r_is_valid` must be assignable.
+    /// - It must be safe to move a [`GString`](crate::builtin::GString) into `r_str`.
     pub(super) unsafe extern "C" fn to_string_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         r_is_valid: *mut sys::GDExtensionBool,
@@ -830,7 +896,8 @@ mod script_instance_info {
         let ctx = || format!("error when calling {}::to_string", type_name::<T>());
 
         let string = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .to_string()
         })
@@ -840,16 +907,19 @@ mod script_instance_info {
             return;
         };
 
-        *r_is_valid = SYS_TRUE;
-        string.move_into_string_ptr(r_str);
+        // SAFETY: `r_is_valid` is assignable.
+        unsafe { *r_is_valid = SYS_TRUE };
+        // SAFETY: It is safe to move a `GString` into `r_str`.
+        unsafe { string.move_into_string_ptr(r_str) };
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - A string name ptr and a const Variant ptr are passed for each script property to the `property_state_add` callback function. The callback is then
-    ///   responsible for freeing the memory.
-    /// - `userdata` has to be a valid pointer that satisfies the invariants of `property_state_add`.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    ///
+    /// If `property_state_add` is non-null, then:
+    /// - It is safe to call `property_state_add` using the provided `userdata`.
+    /// - `property_state_add` must take ownership of the `StringName` and `Variant` it is called with.
     pub(super) unsafe extern "C" fn get_property_state_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         property_state_add: sys::GDExtensionScriptInstancePropertyStateAdd,
@@ -863,7 +933,8 @@ mod script_instance_info {
         };
 
         let property_states = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .get_property_state()
         })
@@ -874,26 +945,31 @@ mod script_instance_info {
         };
 
         for (name, value) in property_states {
-            property_state_add(
-                name.into_owned_string_sys(),
-                value.into_owned_var_sys(),
-                userdata,
-            );
+            // SAFETY: `property_state_add` is non-null, therefore we can call the function with the provided `userdata`.
+            // Additionally `property_state_add` takes ownership of `name` and `value`.
+            unsafe {
+                property_state_add(
+                    name.into_owned_string_sys(),
+                    value.into_owned_var_sys(),
+                    userdata,
+                )
+            }
         }
     }
 
+    /// Ownership of the returned object is not transferred to the caller. The caller must therefore ensure it's not freed when used.
+    ///
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - A ptr to a [`ScriptLanguage´] reference will be returned, ScriptLanguage is a manually managed object and the caller has to verify
-    ///   it's validity as it could be freed at any time.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
     pub(super) unsafe extern "C" fn get_language_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
     ) -> sys::GDExtensionScriptLanguagePtr {
         let ctx = || format!("error when calling {}::get_language", type_name::<T>());
 
         let language = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .get_language()
         });
@@ -907,17 +983,16 @@ mod script_instance_info {
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - The instance data will be freed and the pointer won't be valid anymore after this function has been called.
+    /// - `p_instance` must fulfill the safety preconditions of [`Box::from_raw`] for `Box<ScriptInstanceData<T>>`.
     pub(super) unsafe extern "C" fn free_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
     ) {
-        drop(Box::from_raw(p_instance.cast::<ScriptInstanceData<T>>()));
+        unsafe { drop(Box::from_raw(p_instance.cast::<ScriptInstanceData<T>>())) }
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
     pub(super) unsafe extern "C" fn refcount_decremented_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
     ) -> sys::GDExtensionBool {
@@ -929,18 +1004,19 @@ mod script_instance_info {
         };
 
         let result = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .on_refcount_decremented()
         })
         .unwrap_or(true);
 
-        bool_into_sys(result)
+        bool_to_sys(result)
     }
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
     pub(super) unsafe extern "C" fn refcount_incremented_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
     ) {
@@ -952,7 +1028,8 @@ mod script_instance_info {
         };
 
         handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .on_refcount_incremented();
         })
@@ -961,15 +1038,16 @@ mod script_instance_info {
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `p_name` has to be a valid pointer to a `StringName`.
-    /// - `r_ret` has to be a valid pointer to which the return value can be moved.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_name` must be a valid [`StringName`] pointer.
+    /// - It must be safe to move a `Variant` into `r_ret`.
     pub(super) unsafe extern "C" fn get_fallback_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_name: sys::GDExtensionConstStringNamePtr,
         r_ret: sys::GDExtensionVariantPtr,
     ) -> sys::GDExtensionBool {
-        let name = StringName::new_from_string_sys(p_name);
+        // SAFETY: `p_name` is a valid `StringName` pointer.
+        let name = unsafe { StringName::new_from_string_sys(p_name) };
 
         let ctx = || {
             format!(
@@ -979,14 +1057,16 @@ mod script_instance_info {
         };
 
         let return_value = handle_panic(ctx, || {
-            ScriptInstanceData::<T>::borrow_script_sys(p_instance)
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) }
                 .borrow()
                 .property_get_fallback(name)
         });
 
         match return_value {
             Ok(Some(variant)) => {
-                variant.move_into_var_ptr(r_ret);
+                // SAFETY: It is safe to move a `Variant` into `r_ret`.
+                unsafe { variant.move_into_var_ptr(r_ret) };
                 SYS_TRUE
             }
             _ => SYS_FALSE,
@@ -995,15 +1075,20 @@ mod script_instance_info {
 
     /// # Safety
     ///
-    /// - `p_instance` has to be a valid pointer that can be cast to `*mut ScriptInstanceData<T>`.
-    /// - `p_name` has to be a valid pointer to a `StringName`.
+    /// - `p_instance` must point to a live immutable [`ScriptInstanceData<T>`] for the duration of this function call
+    /// - `p_name` must be a valid [`StringName`] pointer.
+    /// - `p_value` must be a valid [`Variant`] pointer.
     pub(super) unsafe extern "C" fn set_fallback_func<T: ScriptInstance>(
         p_instance: sys::GDExtensionScriptInstanceDataPtr,
         p_name: sys::GDExtensionConstStringNamePtr,
         p_value: sys::GDExtensionConstVariantPtr,
     ) -> sys::GDExtensionBool {
-        let name = StringName::new_from_string_sys(p_name);
-        let value = Variant::borrow_var_sys(p_value);
+        let (name, value);
+        // SAFETY: `p_name` and `p_value` are valid `StringName` and `Variant` pointers respectively.
+        unsafe {
+            name = StringName::new_from_string_sys(p_name);
+            value = Variant::borrow_var_sys(p_value);
+        };
 
         let ctx = || {
             format!(
@@ -1013,7 +1098,8 @@ mod script_instance_info {
         };
 
         let result = handle_panic(ctx, || {
-            let instance = ScriptInstanceData::<T>::borrow_script_sys(p_instance);
+            // SAFETY: `p_instance` points to a live immutable `ScriptInstanceData<T>` for the duration of this call.
+            let instance = unsafe { ScriptInstanceData::<T>::borrow_script_sys(p_instance) };
             let mut guard = instance.borrow_mut();
 
             let instance_guard = SiMut::new(instance.cell_ref(), &mut guard, &instance.base);
@@ -1021,6 +1107,6 @@ mod script_instance_info {
         })
         .unwrap_or_default();
 
-        bool_into_sys(result)
+        bool_to_sys(result)
     }
 }
diff --git a/godot-core/src/registry/callbacks.rs b/godot-core/src/registry/callbacks.rs
index 64d9526c4..f157212dc 100644
--- a/godot-core/src/registry/callbacks.rs
+++ b/godot-core/src/registry/callbacks.rs
@@ -16,6 +16,7 @@ use crate::obj::{cap, Base, GodotClass, UserClass};
 use crate::storage::{as_storage, InstanceStorage, Storage, StorageRefCounted};
 use godot_ffi as sys;
 use std::any::Any;
+use sys::conv::u32_to_usize;
 use sys::interface_fn;
 
 pub unsafe extern "C" fn create<T: cap::GodotDefault>(
@@ -171,9 +172,9 @@ pub unsafe extern "C" fn get_property<T: cap::GodotGet>(
     match T::__godot_get_property(&*instance, property) {
         Some(value) => {
             value.move_into_var_ptr(ret);
-            true as sys::GDExtensionBool
+            sys::conv::SYS_TRUE
         }
-        None => false as sys::GDExtensionBool,
+        None => sys::conv::SYS_FALSE,
     }
 }
 
@@ -188,7 +189,7 @@ pub unsafe extern "C" fn set_property<T: cap::GodotSet>(
     let property = StringName::new_from_string_sys(name);
     let value = Variant::new_from_var_sys(value);
 
-    T::__godot_set_property(&mut *instance, property, value) as sys::GDExtensionBool
+    sys::conv::bool_to_sys(T::__godot_set_property(&mut *instance, property, value))
 }
 
 pub unsafe extern "C" fn reference<T: GodotClass>(instance: sys::GDExtensionClassInstancePtr) {
@@ -247,9 +248,7 @@ pub unsafe extern "C" fn free_property_list<T: cap::GodotGetPropertyList>(
     // This means all the preconditions of this function are satisfied except uniqueness of this point.
     // Uniqueness is guaranteed as Godot called this function at a point where the list is no longer accessed
     // through any other pointer, and we dont access the slice through any other pointer after this call either.
-    let property_list_slice = unsafe {
-        std::slice::from_raw_parts_mut(list, count.try_into().expect("`u32` should fit in `usize`"))
-    };
+    let property_list_slice = unsafe { std::slice::from_raw_parts_mut(list, u32_to_usize(count)) };
 
     // SAFETY: This slice was created by calling `Box::leak` on a `Box<[sys::GDExtensionPropertyInfo]>`, we can thus
     // call `Box::from_raw` on this slice to get back the original boxed slice.
@@ -294,7 +293,7 @@ pub unsafe extern "C" fn property_can_revert<T: cap::GodotPropertyGetRevert>(
     // SAFETY: Godot provides us with a valid `T` instance pointer and `StringName` pointer for the duration of this call.
     let revert = unsafe { raw_property_get_revert::<T>(instance, property_name) };
 
-    revert.is_some() as sys::GDExtensionBool
+    sys::conv::bool_to_sys(revert.is_some())
 }
 
 /// # Safety
@@ -308,7 +307,7 @@ pub unsafe extern "C" fn property_get_revert<T: cap::GodotPropertyGetRevert>(
 ) -> sys::GDExtensionBool {
     // SAFETY: Godot provides us with a valid `T` instance pointer and `StringName` pointer for the duration of this call.
     let Some(revert) = (unsafe { raw_property_get_revert::<T>(instance, property_name) }) else {
-        return false as sys::GDExtensionBool;
+        return sys::conv::SYS_FALSE;
     };
 
     // SAFETY: Godot provides us with a valid `Variant` pointer.
@@ -316,7 +315,7 @@ pub unsafe extern "C" fn property_get_revert<T: cap::GodotPropertyGetRevert>(
         revert.move_into_var_ptr(ret);
     }
 
-    true as sys::GDExtensionBool
+    sys::conv::SYS_TRUE
 }
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Safe, higher-level methods
diff --git a/godot-core/src/registry/class.rs b/godot-core/src/registry/class.rs
index 7f39d6cc4..f21e77681 100644
--- a/godot-core/src/registry/class.rs
+++ b/godot-core/src/registry/class.rs
@@ -246,7 +246,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             // For some reason, certain ABCs like PhysicsBody2D are not marked "virtual" but "abstract".
             //
             // See also: https://github.com/godotengine/godot/pull/58972
-            c.godot_params.is_abstract = (!is_instantiable) as sys::GDExtensionBool;
+            c.godot_params.is_abstract = sys::conv::bool_to_sys(!is_instantiable);
             c.godot_params.free_instance_func = Some(free_fn);
 
             fill_into(
@@ -265,7 +265,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
                 )
                 .expect("duplicate: recreate_instance_func (def)");
 
-                c.godot_params.is_exposed = (!is_hidden) as sys::GDExtensionBool;
+                c.godot_params.is_exposed = sys::conv::bool_to_sys(!is_hidden);
             }
 
             #[cfg(before_api = "4.2")]
@@ -276,7 +276,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             #[cfg(since_api = "4.3")]
             {
                 c.godot_params.is_runtime =
-                    crate::private::is_class_runtime(is_tool) as sys::GDExtensionBool;
+                    sys::conv::bool_to_sys(crate::private::is_class_runtime(is_tool));
             }
         }
 
@@ -498,7 +498,7 @@ fn default_creation_info() -> sys::GDExtensionClassCreationInfo2 {
     sys::GDExtensionClassCreationInfo2 {
         is_virtual: false as u8,
         is_abstract: false as u8,
-        is_exposed: true as sys::GDExtensionBool,
+        is_exposed: sys::conv::SYS_TRUE,
         set_func: None,
         get_func: None,
         get_property_list_func: None,
@@ -526,8 +526,8 @@ fn default_creation_info() -> sys::GDExtensionClassCreationInfo3 {
     sys::GDExtensionClassCreationInfo3 {
         is_virtual: false as u8,
         is_abstract: false as u8,
-        is_exposed: true as sys::GDExtensionBool,
-        is_runtime: true as sys::GDExtensionBool,
+        is_exposed: sys::conv::SYS_TRUE,
+        is_runtime: sys::conv::SYS_TRUE,
         set_func: None,
         get_func: None,
         get_property_list_func: None,
diff --git a/godot-core/src/registry/constant.rs b/godot-core/src/registry/constant.rs
index b4288fcb0..cd4c49bec 100644
--- a/godot-core/src/registry/constant.rs
+++ b/godot-core/src/registry/constant.rs
@@ -39,7 +39,7 @@ impl IntegerConstant {
                 enum_name.string_sys(),
                 self.name.string_sys(),
                 self.value,
-                is_bitfield as sys::GDExtensionBool,
+                sys::conv::bool_to_sys(is_bitfield),
             );
         }
     }
diff --git a/godot-ffi/src/conv.rs b/godot-ffi/src/conv.rs
new file mode 100644
index 000000000..dd0e957a8
--- /dev/null
+++ b/godot-ffi/src/conv.rs
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * 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/.
+ */
+
+//! Conversions from some rust-types into appropriate Godot types.
+
+use std::mem::size_of;
+
+use crate as sys;
+use crate::static_assert;
+
+/// Infallibly convert `u32` into a `usize`.
+///
+/// gdext (and Godot in general) currently only supports targets where `u32` can be infallibly converted into a `usize`.
+pub fn u32_to_usize(i: u32) -> usize {
+    static_assert!(
+        size_of::<u32>() <= size_of::<usize>(),
+        "gdext only supports targets where u32 <= usize"
+    );
+
+    // SAFETY: The above static assert ensures that this can never fail.
+    unsafe { i.try_into().unwrap_unchecked() }
+}
+
+/// Converts a rust-bool into a sys-bool.
+pub const fn bool_to_sys(value: bool) -> sys::GDExtensionBool {
+    value as sys::GDExtensionBool
+}
+
+pub const SYS_TRUE: sys::GDExtensionBool = bool_to_sys(true);
+pub const SYS_FALSE: sys::GDExtensionBool = bool_to_sys(false);
+
+#[cfg(test)]
+mod test {
+    use crate::conv::{bool_to_sys, u32_to_usize, SYS_FALSE, SYS_TRUE};
+
+    #[test]
+    fn sys_bool() {
+        assert_eq!(bool_to_sys(true), SYS_TRUE);
+        assert_eq!(bool_to_sys(false), SYS_FALSE);
+    }
+
+    #[test]
+    fn u32_into_usize_test() {
+        const CHECKS: &[u32] = &[
+            0,
+            123,
+            4444,
+            u32::MAX,
+            u16::MAX as u32,
+            u8::MAX as u32,
+            i8::MAX as u32,
+            i16::MAX as u32,
+            i32::MAX as u32,
+        ];
+
+        for value in CHECKS {
+            assert_eq!(u32_to_usize(*value), *value as usize);
+            assert_eq!(u32_to_usize(*value) as u32, *value);
+        }
+    }
+}
diff --git a/godot-ffi/src/lib.rs b/godot-ffi/src/lib.rs
index 20296addf..6cfbf9205 100644
--- a/godot-ffi/src/lib.rs
+++ b/godot-ffi/src/lib.rs
@@ -22,6 +22,8 @@ pub(crate) mod gen {
     include!(concat!(env!("OUT_DIR"), "/mod.rs"));
 }
 
+pub mod conv;
+
 mod compat;
 mod extras;
 mod global;
diff --git a/itest/godot/ManualFfiTests.gd b/itest/godot/ManualFfiTests.gd
index cf23410ac..8eeaa9c95 100644
--- a/itest/godot/ManualFfiTests.gd
+++ b/itest/godot/ManualFfiTests.gd
@@ -86,13 +86,13 @@ func test_object_pass_to_user_func_ptrcall():
 
 func test_object_return_from_user_func_varcall():
 	var obj_test = ObjectTest.new()
-	var obj: MockObjRust = obj_test.return_object() 
+	var obj: MockObjRust = obj_test.return_object()
 	assert_eq(obj.i, 42)
 	obj.free()
 
 func test_object_return_from_user_func_ptrcall():
 	var obj_test: ObjectTest = ObjectTest.new()
-	var obj: MockObjRust = obj_test.return_object() 
+	var obj: MockObjRust = obj_test.return_object()
 	assert_eq(obj.i, 42)
 	obj.free()
 
@@ -124,22 +124,22 @@ func test_refcounted_as_object_pass_to_user_func_ptrcall():
 
 func test_refcounted_return_from_user_func_varcall():
 	var obj_test = ObjectTest.new()
-	var obj: MockRefCountedRust = obj_test.return_refcounted() 
+	var obj: MockRefCountedRust = obj_test.return_refcounted()
 	assert_eq(obj.i, 42)
 
 func test_refcounted_return_from_user_func_ptrcall():
 	var obj_test: ObjectTest = ObjectTest.new()
-	var obj: MockRefCountedRust = obj_test.return_refcounted() 
+	var obj: MockRefCountedRust = obj_test.return_refcounted()
 	assert_eq(obj.i, 42)
 
 func test_refcounted_as_object_return_from_user_func_varcall():
 	var obj_test = ObjectTest.new()
-	var obj: MockRefCountedRust = obj_test.return_refcounted_as_object() 
+	var obj: MockRefCountedRust = obj_test.return_refcounted_as_object()
 	assert_eq(obj.i, 42)
 
 func test_refcounted_as_object_return_from_user_func_ptrcall():
 	var obj_test: ObjectTest = ObjectTest.new()
-	var obj: MockRefCountedRust = obj_test.return_refcounted_as_object() 
+	var obj: MockRefCountedRust = obj_test.return_refcounted_as_object()
 	assert_eq(obj.i, 42)
 
 func test_custom_constructor():
@@ -263,7 +263,7 @@ func test_custom_property_wrong_values_2():
 
 	var has_property: HasCustomProperty = HasCustomProperty.new()
 	disable_error_messages()
-	has_property.not_exportable = {"a": "hello", "b": Callable()}  # Should fail.
+	has_property.not_exportable = {"a": "hello", "b": Callable()} # Should fail.
 	enable_error_messages()
 	assert_fail("HasCustomProperty.not_exportable should only accept dictionaries with float values")
 
@@ -360,4 +360,3 @@ func test_get_set():
 	assert_eq(obj.set_get, 1000)
 	assert(obj.is_set_called())
 	assert(obj.is_get_called())
-
diff --git a/itest/rust/src/builtin_tests/script/script_instance_tests.rs b/itest/rust/src/builtin_tests/script/script_instance_tests.rs
index f72b49756..94f674030 100644
--- a/itest/rust/src/builtin_tests/script/script_instance_tests.rs
+++ b/itest/rust/src/builtin_tests/script/script_instance_tests.rs
@@ -9,7 +9,7 @@ use std::ffi::c_void;
 
 use godot::builtin::{GString, StringName, Variant, VariantType};
 use godot::classes::{IScriptExtension, Object, Script, ScriptExtension, ScriptLanguage};
-use godot::global::{MethodFlags, PropertyHint, PropertyUsageFlags};
+use godot::global::MethodFlags;
 use godot::meta::{ClassName, FromGodot, MethodInfo, PropertyInfo, ToGodot};
 use godot::obj::script::{create_script_instance, ScriptInstance, SiMut};
 use godot::obj::{Base, Gd, WithBaseField};
@@ -46,44 +46,16 @@ impl TestScriptInstance {
         Self {
             script,
             script_property_b: false,
-            prop_list: vec![PropertyInfo {
-                variant_type: VariantType::INT,
-                property_name: StringName::from("script_property_a"),
-                class_name: ClassName::from_ascii_cstr("\0".as_bytes()),
-                hint: PropertyHint::NONE,
-                hint_string: GString::new(),
-                usage: PropertyUsageFlags::NONE,
-            }],
+            prop_list: vec![PropertyInfo::new_var::<i64>("script_property_a")],
 
             method_list: vec![MethodInfo {
                 id: 1,
                 method_name: StringName::from("script_method_a"),
                 class_name: ClassName::from_ascii_cstr("TestScript\0".as_bytes()),
-                return_type: PropertyInfo {
-                    variant_type: VariantType::STRING,
-                    class_name: ClassName::none(),
-                    property_name: StringName::from(""),
-                    hint: PropertyHint::NONE,
-                    hint_string: GString::new(),
-                    usage: PropertyUsageFlags::NONE,
-                },
+                return_type: PropertyInfo::new_var::<GString>(""),
                 arguments: vec![
-                    PropertyInfo {
-                        variant_type: VariantType::STRING,
-                        class_name: ClassName::none(),
-                        property_name: StringName::from(""),
-                        hint: PropertyHint::NONE,
-                        hint_string: GString::new(),
-                        usage: PropertyUsageFlags::NONE,
-                    },
-                    PropertyInfo {
-                        variant_type: VariantType::INT,
-                        class_name: ClassName::none(),
-                        property_name: StringName::from(""),
-                        hint: PropertyHint::NONE,
-                        hint_string: GString::new(),
-                        usage: PropertyUsageFlags::NONE,
-                    },
+                    PropertyInfo::new_var::<GString>("arg_a"),
+                    PropertyInfo::new_var::<i32>("arg_b"),
                 ],
                 default_arguments: vec![],
                 flags: MethodFlags::NORMAL,