Fix various issues with pointer calls

Make `Gd` in virtual method-calls use `ref_get_object`/`ref_set_object` if it inherits from `RefCounted`
Add some tests of objects in pointer calls
Add tests for Array passing through pointer calls
Add more tests for refcounted
Add a test for _input
Rename some stuff in TestContext
Add unsafe to rect and such GodotFfi impl along with `SAFETY` comments

Author: lilizoey

godot-codegen/src/central_generator.rs

@@ -176,7 +176,9 @@ fn make_sys_code(central_items: &CentralItems) -> String {
             }
         }
 
-        impl GodotFfi for VariantType {
+        // SAFETY:
+        // This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+        unsafe impl GodotFfi for VariantType {
             ffi_methods! { type GDExtensionTypePtr = *mut Self; .. }
         }
 
@@ -205,7 +207,9 @@ fn make_sys_code(central_items: &CentralItems) -> String {
             }
         }
 
-        impl GodotFfi for VariantOperator {
+        // SAFETY:
+        // This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+        unsafe impl GodotFfi for VariantOperator {
             ffi_methods! { type GDExtensionTypePtr = *mut Self; .. }
         }
     };

godot-codegen/src/lib.rs

@@ -271,6 +271,8 @@ const SELECTED_CLASSES: &[&str] = &[
     "Image",
     "ImageTextureLayered",
     "Input",
+    "InputEvent",
+    "InputEventAction",
     "Label",
     "MainLoop",
     "Marker2D",
@@ -296,4 +298,6 @@ const SELECTED_CLASSES: &[&str] = &[
     "TextureLayered",
     "Time",
     "Timer",
+    "Window",
+    "Viewport",
 ];

godot-codegen/src/util.rs

@@ -99,7 +99,7 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
                 self.ord
             }
         }
-        impl sys::GodotFfi for #enum_name {
+        unsafe impl sys::GodotFfi for #enum_name {
             sys::ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
         }
         #bitfield_ops

godot-core/src/builtin/aabb.rs

@@ -82,6 +82,8 @@ impl Aabb {
     */
 }
 
-impl GodotFfi for Aabb {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Aabb {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/array.rs

@@ -566,8 +566,26 @@ impl<T: VariantMetadata + ToVariant> Array<T> {
 //     ...
 // }
 
-impl<T: VariantMetadata> GodotFfi for Array<T> {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+unsafe impl<T: VariantMetadata> GodotFfi for Array<T> {
+    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;
+        fn from_sys;
+        fn sys;
+        fn from_sys_init;
+        // SAFETY:
+        // Nothing special needs to be done beyond a `std::mem::swap` when returning an Array.
+        fn move_return_ptr;
+    }
+
+    // SAFETY:
+    // Arrays are properly initialized through a `from_sys` call, but the ref-count should be
+    // incremented as that is the callee's responsibility.
+    //
+    // Using `std::mem::forget(array.share())` increments the ref count.
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::CallType) -> Self {
+        let array = Self::from_sys(ptr);
+        std::mem::forget(array.share());
+        array
+    }
 
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();

godot-core/src/builtin/basis.rs

@@ -570,7 +570,9 @@ impl Mul<Vector3> for Basis {
     }
 }
 
-impl GodotFfi for Basis {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Basis {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 

godot-core/src/builtin/color.rs

@@ -311,7 +311,9 @@ impl Color {
     }
 }
 
-impl GodotFfi for Color {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Color {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 

godot-core/src/builtin/dictionary.rs

@@ -239,8 +239,26 @@ impl Dictionary {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Traits
 
-impl GodotFfi for Dictionary {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+unsafe impl GodotFfi for Dictionary {
+    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;
+        fn from_sys;
+        fn from_sys_init;
+        fn sys;
+        // SAFETY:
+        // Nothing special needs to be done beyond a `std::mem::swap` when returning a dictionary.
+        fn move_return_ptr;
+    }
+
+    // SAFETY:
+    // Dictionaries are properly initialized through a `from_sys` call, but the ref-count should be 
+    // incremented as that is the callee's responsibility.
+    //
+    // Using `std::mem::forget(dictionary.share())` increments the ref count.
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::CallType) -> Self {
+        let dictionary = Self::from_sys(ptr);
+        std::mem::forget(dictionary.share());
+        dictionary
+    }
 
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();

godot-core/src/builtin/macros.rs

@@ -157,7 +157,10 @@ macro_rules! impl_builtin_stub {
             }
         }
 
-        impl GodotFfi for $Class {
+        // SAFETY:
+        // This is simply a wrapper around an `Opaque` value representing a value of the type.
+        // So this is safe.
+        unsafe impl GodotFfi for $Class {
             ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
         }
     };

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

@@ -34,6 +34,7 @@ pub trait SignatureTuple {
         ret: sys::GDExtensionTypePtr,
         func: fn(&mut C, Self::Params) -> Self::Ret,
         method_name: &str,
+        call_type: sys::CallType,
     );
 }
 
@@ -143,6 +144,7 @@ macro_rules! impl_signature_for_tuple {
                 ret: sys::GDExtensionTypePtr,
                 func: fn(&mut C, Self::Params) -> Self::Ret,
                 method_name: &str,
+                call_type: sys::CallType,
             ) {
                 $crate::out!("ptrcall: {}", method_name);
 
@@ -151,20 +153,20 @@ macro_rules! impl_signature_for_tuple {
 
 				let args = ( $(
                     unsafe {
-                        <$Pn as sys::GodotFuncMarshal>::try_from_sys(
-                            sys::force_mut_ptr(*args_ptr.offset($n))
+                        <$Pn as sys::GodotFuncMarshal>::try_from_arg(
+                            sys::force_mut_ptr(*args_ptr.offset($n)),
+                            call_type
                         )
                     }
                         .unwrap_or_else(|e| param_error::<$Pn>(method_name, $n, &e)),
                 )* );
 
                 let ret_val = func(&mut *instance, args);
-				unsafe { <$R as sys::GodotFuncMarshal>::try_write_sys(&ret_val, ret) }
-                    .unwrap_or_else(|e| return_error::<$R>(method_name, &e));
-
-               //Note: we want to prevent the destructor from being run, since we pass ownership to the caller.
-               //https://github.com/godot-rust/gdext/pull/165
-				std::mem::forget(ret_val);
+                // SAFETY:
+                // `ret` is always a pointer to an initialized value of type $R
+                // TODO: double-check the above
+				<$R as sys::GodotFuncMarshal>::try_return(ret_val, ret, call_type)
+                    .unwrap_or_else(|ret_val| return_error::<$R>(method_name, &ret_val));
             }
         }
     };

godot-core/src/builtin/node_path.rs

@@ -22,8 +22,26 @@ impl NodePath {
     }
 }
 
-impl GodotFfi for NodePath {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+unsafe impl GodotFfi for NodePath {
+    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;
+        fn from_sys;
+        fn sys;
+        fn from_sys_init;
+        // SAFETY:
+        // Nothing special needs to be done beyond a `std::mem::swap` when returning a NodePath.
+        fn move_return_ptr;
+    }
+
+    // SAFETY:
+    // NodePaths are properly initialized through a `from_sys` call, but the ref-count should be
+    // incremented as that is the callee's responsibility.
+    //
+    // Using `std::mem::forget(node_path.share())` increments the ref count.
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::CallType) -> Self {
+        let node_path = Self::from_sys(ptr);
+        std::mem::forget(node_path.clone());
+        node_path
+    }
 
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();

godot-core/src/builtin/packed_array.rs

@@ -390,8 +390,26 @@ macro_rules! impl_packed_array {
             }
         }
 
-        impl GodotFfi for $PackedArray {
-            ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+        unsafe impl GodotFfi for $PackedArray {
+            ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;
+                fn from_sys;
+                fn sys;
+                fn from_sys_init;
+                // SAFETY:
+                // Nothing special needs to be done beyond a `std::mem::swap` when returning a packed array.
+                fn move_return_ptr;
+            }
+
+            // SAFETY:
+            // Packed arrays are properly initialized through a `from_sys` call, but the ref-count should be
+            // incremented as that is the callee's responsibility.
+            //
+            // Using `std::mem::forget(array.clone())` increments the ref count.
+            unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::CallType) -> Self {
+                let array = Self::from_sys(ptr);
+                std::mem::forget(array.clone());
+                array
+            }
 
             unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
                 let mut result = Self::default();

godot-core/src/builtin/plane.rs

@@ -134,7 +134,9 @@ impl Neg for Plane {
     }
 }
 
-impl GodotFfi for Plane {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Plane {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 

godot-core/src/builtin/projection.rs

@@ -486,7 +486,9 @@ impl GlamConv for Projection {
     type Glam = RMat4;
 }
 
-impl GodotFfi for Projection {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Projection {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 

godot-core/src/builtin/quaternion.rs

@@ -254,7 +254,9 @@ impl Mul<Quaternion> for Quaternion {
     }
 }
 
-impl GodotFfi for Quaternion {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Quaternion {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 

godot-core/src/builtin/rect2.rs

@@ -104,6 +104,8 @@ impl Rect2 {
     */
 }
 
-impl GodotFfi for Rect2 {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Rect2 {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/rect2i.rs

@@ -93,6 +93,8 @@ impl Rect2i {
     */
 }
 
-impl GodotFfi for Rect2i {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Rect2i {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/rid.rs

@@ -81,6 +81,8 @@ impl Rid {
     }
 }
 
-impl GodotFfi for Rid {
+// SAFETY:
+// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+unsafe impl GodotFfi for Rid {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/string.rs

@@ -35,7 +35,14 @@ impl GodotString {
         fn from_string_sys = from_sys;
         fn from_string_sys_init = from_sys_init;
         fn string_sys = sys;
-        fn write_string_sys = write_sys;
+    }
+
+    /// Move `self` into a system pointer.
+    ///
+    /// # Safety
+    /// `dst` must be a pointer to a `GodotString` which is suitable for ffi with Godot.
+    pub unsafe fn move_string_ptr(self, dst: sys::GDExtensionStringPtr) {
+        self.move_return_ptr(dst as *mut _, sys::CallType::Standard);
     }
 
     /// Gets the internal chars slice from a [`GodotString`].
@@ -68,8 +75,26 @@ impl GodotString {
     }
 }
 
-impl GodotFfi for GodotString {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+unsafe impl GodotFfi for GodotString {
+    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;
+        fn from_sys;
+        fn sys;
+        fn from_sys_init;
+        // SAFETY:
+        // Nothing special needs to be done beyond a `std::mem::swap` when returning a GodotString.
+        fn move_return_ptr;
+    }
+
+    // SAFETY:
+    // GodotStrings are properly initialized through a `from_sys` call, but the ref-count should be
+    // incremented as that is the callee's responsibility.
+    //
+    // Using `std::mem::forget(string.share())` increments the ref count.
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::CallType) -> Self {
+        let string = Self::from_sys(ptr);
+        std::mem::forget(string.clone());
+        string
+    }
 
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();

godot-core/src/builtin/string_name.rs

@@ -28,12 +28,29 @@ impl StringName {
         fn from_string_sys = from_sys;
         fn from_string_sys_init = from_sys_init;
         fn string_sys = sys;
-        fn write_string_sys = write_sys;
     }
 }
 
-impl GodotFfi for StringName {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+unsafe impl GodotFfi for StringName {
+    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque;
+        fn from_sys;
+        fn sys;
+        fn from_sys_init;
+        // SAFETY:
+        // Nothing special needs to be done beyond a `std::mem::swap` when returning a StringName.
+        fn move_return_ptr;
+    }
+
+    // SAFETY:
+    // StringNames are properly initialized through a `from_sys` call, but the ref-count should be
+    // incremented as that is the callee's responsibility.
+    //
+    // Using `std::mem::forget(string_name.share())` increments the ref count.
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::CallType) -> Self {
+        let string_name = Self::from_sys(ptr);
+        std::mem::forget(string_name.clone());
+        string_name
+    }
 
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();