Fix return virtual method type

Add another virtual method return test
Make test that causes memory leak use `#[itest(skip)]`
Move the logic for determining whether to use `Ref` or not entirely into `Mem`
Remove some unnecessary manual ffi tests
Rename CallType

Author: lilizoey

godot-codegen/src/central_generator.rs

@@ -177,7 +177,7 @@ fn make_sys_code(central_items: &CentralItems) -> String {
         }
 
         // SAFETY:
-        // This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+        // This type is represented as `Self` in Godot, so `*mut Self` is sound.
         unsafe impl GodotFfi for VariantType {
             ffi_methods! { type GDExtensionTypePtr = *mut Self; .. }
         }
@@ -208,7 +208,7 @@ fn make_sys_code(central_items: &CentralItems) -> String {
         }
 
         // SAFETY:
-        // This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+        // This type is 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

@@ -258,6 +258,7 @@ const SELECTED_CLASSES: &[&str] = &[
     "AudioStreamPlayer",
     "BaseButton",
     "Button",
+    "BoxMesh",
     "Camera2D",
     "Camera3D",
     "CanvasItem",
@@ -276,6 +277,7 @@ const SELECTED_CLASSES: &[&str] = &[
     "Label",
     "MainLoop",
     "Marker2D",
+    "Mesh",
     "Node",
     "Node2D",
     "Node3D",
@@ -285,9 +287,11 @@ const SELECTED_CLASSES: &[&str] = &[
     "PackedScene",
     "PathFollow2D",
     "PhysicsBody2D",
+    "PrimitiveMesh",
     "RefCounted",
     "RenderingServer",
     "Resource",
+    "ResourceFormatLoader",
     "ResourceLoader",
     "RigidBody2D",
     "SceneTree",

godot-codegen/src/util.rs

@@ -99,6 +99,8 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
                 self.ord
             }
         }
+        // SAFETY:
+        // The enums are transparently represented as an `i32`, so `*mut Self` is sound.
         unsafe impl sys::GodotFfi for #enum_name {
             sys::ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
         }

godot-core/src/builtin/aabb.rs

@@ -83,7 +83,7 @@ impl Aabb {
 }
 
 // SAFETY:
-// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+// This type is 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,22 +566,23 @@ impl<T: VariantMetadata + ToVariant> Array<T> {
 //     ...
 // }
 
+// SAFETY:
+// - `move_return_ptr`
+//   Nothing special needs to be done beyond a `std::mem::swap` when returning an Array.
+//   So we can just use `ffi_methods`.
+//
+// - `from_arg_ptr`
+//   Arrays are properly initialized through a `from_sys` call, but the ref-count should be incremented
+//   as that is the callee's responsibility. Which we do by calling `std::mem::forget(array.share())`.
 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 {
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::PtrcallType) -> Self {
         let array = Self::from_sys(ptr);
         std::mem::forget(array.share());
         array

godot-core/src/builtin/basis.rs

@@ -571,7 +571,7 @@ impl Mul<Vector3> for Basis {
 }
 
 // SAFETY:
-// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+// This type is 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

@@ -312,7 +312,7 @@ impl Color {
 }
 
 // SAFETY:
-// This type is transparently represented as `Self` in Godot, so `*mut Self` is sound.
+// This type is 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,22 +239,24 @@ impl Dictionary {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Traits
 
+// SAFETY:
+// - `move_return_ptr`
+//   Nothing special needs to be done beyond a `std::mem::swap` when returning an Dictionary.
+//   So we can just use `ffi_methods`.
+//
+// - `from_arg_ptr`
+//   Dictionaries are properly initialized through a `from_sys` call, but the ref-count should be
+//   incremented as that is the callee's responsibility. Which we do by calling
+//   `std::mem::forget(dictionary.share())`.
 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 {
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::PtrcallType) -> Self {
         let dictionary = Self::from_sys(ptr);
         std::mem::forget(dictionary.share());
         dictionary

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

@@ -34,7 +34,7 @@ pub trait SignatureTuple {
         ret: sys::GDExtensionTypePtr,
         func: fn(&mut C, Self::Params) -> Self::Ret,
         method_name: &str,
-        call_type: sys::CallType,
+        call_type: sys::PtrcallType,
     );
 }
 
@@ -144,7 +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,
+                call_type: sys::PtrcallType,
             ) {
                 $crate::out!("ptrcall: {}", method_name);
 

godot-core/src/builtin/node_path.rs

@@ -22,22 +22,24 @@ impl NodePath {
     }
 }
 
+// SAFETY:
+// - `move_return_ptr`
+//   Nothing special needs to be done beyond a `std::mem::swap` when returning a NodePath.
+//   So we can just use `ffi_methods`.
+//
+// - `from_arg_ptr`
+//   NodePaths are properly initialized through a `from_sys` call, but the ref-count should be
+//   incremented as that is the callee's responsibility. Which we do by calling
+//   `std::mem::forget(node_path.share())`.
 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 {
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::PtrcallType) -> Self {
         let node_path = Self::from_sys(ptr);
         std::mem::forget(node_path.clone());
         node_path