Native structure + other pointers now implement Engine{To,From}Godot, not {To,FromGodot}

Author: Bromeon

godot-codegen/src/generator/native_structures.rs

@@ -88,17 +88,15 @@ fn make_native_structure(
 
     let imports = util::make_imports();
     let (fields, methods) = make_native_structure_fields_and_methods(structure, ctx);
-    let doc = format!("[`ToGodot`] and [`FromGodot`] are implemented for `*mut {class_name}` and `*const {class_name}`.");
 
     // mod re_export needed, because class should not appear inside the file module, and we can't re-export private struct as pub
     let tokens = quote! {
         #imports
         use std::ffi::c_void; // for opaque object pointer fields
-        use crate::meta::{GodotConvert, FromGodot, ToGodot};
+        use crate::meta::{GodotConvert, EngineFromGodot, EngineToGodot};
 
         /// Native structure; can be passed via pointer in APIs that are not exposed to GDScript.
         ///
-        #[doc = #doc]
         #[derive(Clone, PartialEq, Debug)]
         #[repr(C)]
         pub struct #class_name {
@@ -113,36 +111,53 @@ fn make_native_structure(
             type Via = i64;
         }
 
-        impl ToGodot for *mut #class_name {
+        // 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 to_godot(&self) -> Self::Via {
+            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 FromGodot for *mut #class_name {
-            fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
+        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 ToGodot for *const #class_name {
+        impl EngineToGodot for *const #class_name {
             type Pass = crate::meta::ByValue;
 
-            fn to_godot(&self) -> Self::Via {
+            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 FromGodot for *const #class_name {
-            fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
+        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)
+            }
         }
     };
     // note: TypePtr -> ObjectPtr conversion OK?

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

@@ -460,18 +460,27 @@ macro_rules! impl_pointer_convert {
             type Via = i64;
         }
 
-        impl ToGodot for $Ptr {
+        // Pointers implement internal-only conversion traits for use in engine APIs and virtual methods.
+        impl meta::EngineToGodot for $Ptr {
             type Pass = meta::ByValue;
 
-            fn to_godot(&self) -> Self::Via {
+            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 FromGodot for $Ptr {
-            fn try_from_godot(via: Self::Via) -> Result<Self, ConvertError> {
+        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)
+            }
         }
     };
 }
@@ -480,7 +489,7 @@ impl_pointer_convert!(*const std::ffi::c_void);
 impl_pointer_convert!(*mut std::ffi::c_void);
 
 // Some other pointer types are used by various other methods, see https://github.com/godot-rust/gdext/issues/677
-// TODO: Find better solution to this, this may easily break still if godot decides to add more pointer arguments.
+// 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);