Merge branch 'master' into feature/object-notification

# Conflicts:
#	itest/rust/src/virtual_methods_test.rs

Author: Bromeon

godot-codegen/src/central_generator.rs

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

@@ -842,6 +842,12 @@ fn make_method_definition(
             __method_name.string_sys(),
             #hash
         );
+        assert!(
+            !__method_bind.is_null(),
+            "failed to load method {}::{} -- possible Godot and gdext version mismatch",
+            #class_name_str,
+            #method_name_str
+        );
         let __call_fn = sys::interface_fn!(#function_provider);
     };
     let varcall_invocation = quote! {

godot-codegen/src/lib.rs

@@ -262,6 +262,7 @@ const SELECTED_CLASSES: &[&str] = &[
     "AudioStreamPlayer",
     "BaseButton",
     "Button",
+    "BoxMesh",
     "Camera2D",
     "Camera3D",
     "CanvasItem",
@@ -275,9 +276,12 @@ const SELECTED_CLASSES: &[&str] = &[
     "Image",
     "ImageTextureLayered",
     "Input",
+    "InputEvent",
+    "InputEventAction",
     "Label",
     "MainLoop",
     "Marker2D",
+    "Mesh",
     "Node",
     "Node2D",
     "Node3D",
@@ -287,9 +291,11 @@ const SELECTED_CLASSES: &[&str] = &[
     "PackedScene",
     "PathFollow2D",
     "PhysicsBody2D",
+    "PrimitiveMesh",
     "RefCounted",
     "RenderingServer",
     "Resource",
+    "ResourceFormatLoader",
     "ResourceLoader",
     "RigidBody2D",
     "SceneTree",
@@ -300,4 +306,6 @@ const SELECTED_CLASSES: &[&str] = &[
     "TextureLayered",
     "Time",
     "Timer",
+    "Window",
+    "Viewport",
 ];

godot-codegen/src/util.rs

@@ -99,7 +99,9 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
                 self.ord
             }
         }
-        impl sys::GodotFfi for #enum_name {
+        // 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; .. }
         }
         #bitfield_ops

godot-core/src/builtin/aabb.rs

@@ -82,6 +82,8 @@ impl Aabb {
     */
 }
 
-impl GodotFfi for Aabb {
+// SAFETY:
+// 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,8 +566,27 @@ impl<T: VariantMetadata + ToVariant> Array<T> {
 //     ...
 // }
 
-impl<T: VariantMetadata> GodotFfi for Array<T> {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+// 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;
+        fn move_return_ptr;
+    }
+
+    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
+    }
 
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();
@@ -855,7 +874,7 @@ macro_rules! varray {
 /// [`set_typed`](https://docs.godotengine.org/en/latest/classes/class_array.html#class-array-method-set-typed).
 ///
 /// We ignore the `script` parameter because it has no impact on typing in Godot.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(PartialEq, Eq)]
 struct TypeInfo {
     variant_type: VariantType,
     class_name: StringName,
@@ -880,3 +899,16 @@ impl TypeInfo {
         self.variant_type != VariantType::Nil
     }
 }
+
+impl fmt::Debug for TypeInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let class = self.class_name.to_string();
+        let class_str = if class.is_empty() {
+            String::new()
+        } else {
+            format!(" (class={class})")
+        };
+
+        write!(f, "{:?}{}", self.variant_type, class_str)
+    }
+}

godot-core/src/builtin/basis.rs

@@ -570,7 +570,9 @@ impl Mul<Vector3> for Basis {
     }
 }
 
-impl GodotFfi for Basis {
+// SAFETY:
+// 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

@@ -311,7 +311,9 @@ impl Color {
     }
 }
 
-impl GodotFfi for Color {
+// SAFETY:
+// 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,8 +239,28 @@ impl Dictionary {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Traits
 
-impl GodotFfi for Dictionary {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Opaque; .. }
+// 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;
+        fn move_return_ptr;
+    }
+
+    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
+    }
 
     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; .. }
         }
     };