Unify raw pointer FFI passing with RawPtr<P> type

Removes all direct `ToGodot`, `FromGodot`, `EngineToGodot` and `EngineFromGodot` impls
for raw pointers, and instead adds 1 generic impl for `RawPtr<P>`. Also enforces unsafe
construction, which wasn't the case so far -- you could e.g. return a `*const Glyph*` to a
local variable from `#[func]` without ever typing `unsafe` and causing UB on Godot side.

Raw pointers appear in three forms:
1. Native structures
2. Hardcoded basic types (`c_void`, `i32`, ...)
3. GDExtension sys pointers (e.g. `GDExtensionInitializationFunction` used in `GDExtensionManager::load_extension_from_function`)

This makes engine APIs dealing with pointers slightly less convenient to use, but probably
OK given their niche domain. For now, `RawPtr<P>` is blanket-implemented for all raw
pointers. It would be possible to only implement it for a dedicated list, but may not be
worth the effort to maintain it.

Adds `unsafe` to some previously safe APIs like `PhysicsServer2DExtensionShapeResult::set_collider()`.

Author: Bromeon

godot-codegen/src/context.rs

@@ -254,6 +254,7 @@ impl<'a> Context<'a> {
 
     /// Yields cached sys pointer types – various pointer types declared in `gdextension_interface`
     /// and used as parameters in exposed Godot APIs.
+    #[allow(dead_code)] // Currently unused, as RawPtr<P> covers all raw pointers.
     pub fn cached_sys_pointer_types(&self) -> impl Iterator<Item = &RustTy> {
         self.cached_rust_types
             .values()

godot-codegen/src/generator/central_files.rs

@@ -10,7 +10,6 @@ use quote::{format_ident, quote, ToTokens};
 
 use crate::context::Context;
 use crate::conv;
-use crate::generator::sys_pointer_types::make_godotconvert_for_systypes;
 use crate::generator::{enums, gdext_build_struct};
 use crate::models::domain::{ExtensionApi, FlowDirection};
 use crate::util::ident;
@@ -61,7 +60,6 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
 
     let (global_enum_defs, global_reexported_enum_defs) = make_global_enums(api);
     let variant_type_traits = make_variant_type_enum(api, false);
-    let sys_types_godotconvert_impl = make_godotconvert_for_systypes(ctx);
 
     // TODO impl Clone, Debug, PartialEq, PartialOrd, Hash for VariantDispatch
     // TODO could use try_to().unwrap_unchecked(), since type is already verified. Also directly overload from_variant().
@@ -119,15 +117,10 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
             #( #global_enum_defs )*
         }
 
-       pub mod global_reexported_enums {
+        pub mod global_reexported_enums {
             use crate::sys;
             #( #global_reexported_enum_defs )*
         }
-
-        pub mod sys_pointer_types {
-            use crate::sys;
-            #( #sys_types_godotconvert_impl )*
-        }
     }
 }
 

godot-codegen/src/generator/mod.rs

@@ -28,7 +28,6 @@ pub mod method_tables;
 pub mod native_structures;
 pub mod notifications;
 pub mod signals;
-pub mod sys_pointer_types;
 pub mod utility_functions;
 pub mod virtual_definitions;
 pub mod virtual_traits;

godot-codegen/src/generator/native_structures.rs

@@ -93,7 +93,6 @@ fn make_native_structure(
     let tokens = quote! {
         #imports
         use std::ffi::c_void; // for opaque object pointer fields
-        use crate::meta::{GodotConvert, EngineFromGodot, EngineToGodot};
 
         /// Native structure; can be passed via pointer in APIs that are not exposed to GDScript.
         ///
@@ -107,58 +106,7 @@ fn make_native_structure(
             #methods
         }
 
-        impl GodotConvert for *mut #class_name {
-            type Via = i64;
-        }
-
-        // Native structure pointers implement internal-only conversion traits for use in engine APIs.
-        impl EngineToGodot for *mut #class_name {
-            type Pass = crate::meta::ByValue;
-
-            fn engine_to_godot(&self) -> crate::meta::ToArg<'_, Self::Via, Self::Pass> {
-                *self as i64
-            }
-
-            fn engine_to_variant(&self) -> crate::builtin::Variant {
-                crate::builtin::Variant::from(*self as i64)
-            }
-        }
-
-        impl EngineFromGodot for *mut #class_name {
-            fn engine_try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
-                Ok(via as Self)
-            }
-
-            fn engine_try_from_variant(variant: &crate::builtin::Variant) -> Result<Self, crate::meta::error::ConvertError> {
-                variant.try_to::<i64>().map(|i| i as Self)
-            }
-        }
-
-        impl GodotConvert for *const #class_name {
-            type Via = i64;
-        }
-
-        impl EngineToGodot for *const #class_name {
-            type Pass = crate::meta::ByValue;
-
-            fn engine_to_godot(&self) -> crate::meta::ToArg<'_, Self::Via, Self::Pass> {
-                *self as i64
-            }
-
-            fn engine_to_variant(&self) -> crate::builtin::Variant {
-                crate::builtin::Variant::from(*self as i64)
-            }
-        }
-
-        impl EngineFromGodot for *const #class_name {
-            fn engine_try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
-                Ok(via as Self)
-            }
-
-            fn engine_try_from_variant(variant: &crate::builtin::Variant) -> Result<Self, crate::meta::error::ConvertError> {
-                variant.try_to::<i64>().map(|i| i as Self)
-            }
-        }
+        // Pointer conversions are now handled by RawPtr<P>, no direct ToGodot/FromGodot impls.
     };
     // note: TypePtr -> ObjectPtr conversion OK?
 
@@ -233,7 +181,11 @@ fn make_native_structure_field_and_accessor(
             }
 
             /// Sets the object from a `Gd` pointer holding `Node` or a derived class.
-            pub fn #setter_name<T>(&mut self, #snake_field_name: Gd<T>)
+            ///
+            /// # Safety
+            /// You must ensure that the provided object remains alive while Godot accesses it.
+            /// See also [`RawPtr::new()`][crate::meta::RawPtr::new].
+            pub unsafe fn #setter_name<T>(&mut self, #snake_field_name: Gd<T>)
             where T: crate::obj::Inherits<Object> {
                 use crate::meta::GodotType as _;
 
@@ -245,7 +197,10 @@ fn make_native_structure_field_and_accessor(
                 let id = obj.instance_id().to_u64();
 
                 self.#id_field_name = ObjectId { id };
-                self.#field_name = obj.obj_sys() as *mut std::ffi::c_void;
+
+                // SAFETY: provided by method safety contract.
+                // Godot declares void* but expects GDExtensionObjectPtr.
+                self.#field_name = unsafe { RawPtr::new(obj.obj_sys().cast::<std::ffi::c_void>()) };
             }
         });
     } else {

godot-codegen/src/generator/sys_pointer_types.rs

@@ -902,11 +902,11 @@ impl ToTokens for RustTy {
             RustTy::RawPointer {
                 inner,
                 is_const: true,
-            } => quote! { *const #inner }.to_tokens(tokens),
+            } => quote! { crate::meta::RawPtr<*const #inner> }.to_tokens(tokens),
             RustTy::RawPointer {
                 inner,
                 is_const: false,
-            } => quote! { *mut #inner }.to_tokens(tokens),
+            } => quote! { crate::meta::RawPtr<*mut #inner> }.to_tokens(tokens),
             RustTy::EngineArray { tokens: path, .. } => path.to_tokens(tokens),
             RustTy::EngineEnum { tokens: path, .. } => path.to_tokens(tokens),
             RustTy::EngineClass {

godot-codegen/src/models/domain.rs

@@ -25,7 +25,7 @@ pub fn make_imports() -> TokenStream {
     quote! {
         use godot_ffi as sys;
         use crate::builtin::*;
-        use crate::meta::{AsArg, ClassId, CowArg, InParamTuple, OutParamTuple, ParamTuple, RefArg, Signature};
+        use crate::meta::{AsArg, ClassId, CowArg, InParamTuple, OutParamTuple, ParamTuple, RawPtr, RefArg, Signature};
         use crate::classes::native::*;
         use crate::classes::Object;
         use crate::obj::Gd;

godot-codegen/src/util.rs

@@ -450,52 +450,18 @@ impl<T: ArrayElement> ToGodot for &[T] {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Raw pointers
 
-// const void* is used in some APIs like OpenXrApiExtension::transform_from_pose().
-// void* is used by ScriptExtension::instance_create().
-// Other impls for raw pointers are generated for native structures.
-
-macro_rules! impl_pointer_convert {
-    ($Ptr:ty) => {
-        impl GodotConvert for $Ptr {
-            type Via = i64;
-        }
-
-        // Pointers implement internal-only conversion traits for use in engine APIs and virtual methods.
-        impl meta::EngineToGodot for $Ptr {
-            type Pass = meta::ByValue;
-
-            fn engine_to_godot(&self) -> meta::ToArg<'_, Self::Via, Self::Pass> {
-                *self as i64
-            }
-
-            fn engine_to_variant(&self) -> Variant {
-                Variant::from(*self as i64)
-            }
-        }
-
-        impl meta::EngineFromGodot for $Ptr {
-            fn engine_try_from_godot(via: Self::Via) -> Result<Self, ConvertError> {
-                Ok(via as Self)
-            }
-
-            fn engine_try_from_variant(variant: &Variant) -> Result<Self, ConvertError> {
-                variant.try_to::<i64>().map(|i| i as Self)
-            }
-        }
-    };
-}
-
-impl_pointer_convert!(*const std::ffi::c_void);
-impl_pointer_convert!(*mut std::ffi::c_void);
-
+// Following types used to be manually implemented, but are now covered by RawPtr<P>.
+// - *mut *const u8
+// - *mut i32
+// - *mut f64
+// - *mut u8
+// - *const u8
+//
+// *const c_void: is used in some APIs like OpenXrApiExtension::transform_from_pose().
+// *mut c_void: is used by ScriptExtension::instance_create().
+//
+// Other impls for raw pointers are generated for native structures and sys pointers (e.g. GDExtensionManager::load_extension_from_function).
 // Some other pointer types are used by various other methods, see https://github.com/godot-rust/gdext/issues/677
-// Keep manually extending this; no point in automating with how rarely Godot adds new pointer types.
-
-impl_pointer_convert!(*mut *const u8);
-impl_pointer_convert!(*mut i32);
-impl_pointer_convert!(*mut f64);
-impl_pointer_convert!(*mut u8);
-impl_pointer_convert!(*const u8);
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Tests for ToGodot/FromGodot missing impls

godot-core/src/meta/godot_convert/impls.rs

@@ -51,6 +51,7 @@ mod method_info;
 mod object_to_owned;
 mod param_tuple;
 mod property_info;
+mod raw_ptr;
 mod signature;
 mod traits;
 mod uniform_object_deref;
@@ -71,6 +72,7 @@ pub use method_info::MethodInfo;
 pub use object_to_owned::ObjectToOwned;
 pub use param_tuple::{InParamTuple, OutParamTuple, ParamTuple, TupleFromGodot};
 pub use property_info::{PropertyHintInfo, PropertyInfo};
+pub use raw_ptr::{FfiRawPointer, RawPtr};
 #[cfg(feature = "trace")]
 pub use signature::trace;
 #[doc(hidden)]