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,