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));
             }
         }
     };