Wire up with GodotNullableFfi

Author: Bromeon

godot-codegen/src/generator/native_structures.rs

@@ -83,59 +83,59 @@ fn make_native_structure(
 
     // 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};
-
-           /// 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 {
-               #fields
-           }
-
-           impl #class_name {
-               #methods
-           }
-
-           impl GodotConvert for *mut #class_name {
-               type Via = i64;
-           }
-
-           impl ToGodot for *mut #class_name {
-               type ToVia<'v> = i64;
-
-               fn to_godot(&self) -> Self::ToVia<'_> {
-                   *self as i64
-               }
-           }
-
-           impl FromGodot for *mut #class_name {
-               fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
-                   Ok(via as Self)
-               }
-           }
-
-           impl GodotConvert for *const #class_name {
-               type Via = i64;
-           }
-
-           impl ToGodot for *const #class_name {
-               type ToVia<'v> = i64;
-
-               fn to_godot(&self) -> Self::ToVia<'_> {
-                   *self as i64
-               }
-           }
-
-           impl FromGodot for *const #class_name {
-               fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
-                   Ok(via as Self)
-               }
-           }
-       };
+        #imports
+        use std::ffi::c_void; // for opaque object pointer fields
+        use crate::meta::{GodotConvert, FromGodot, ToGodot};
+
+        /// 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 {
+            #fields
+        }
+
+        impl #class_name {
+            #methods
+        }
+
+        impl GodotConvert for *mut #class_name {
+            type Via = i64;
+        }
+
+        impl ToGodot for *mut #class_name {
+            type ToVia<'v> = i64;
+
+            fn to_godot(&self) -> Self::ToVia<'_> {
+                *self as i64
+            }
+        }
+
+        impl FromGodot for *mut #class_name {
+            fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
+                Ok(via as Self)
+            }
+        }
+
+        impl GodotConvert for *const #class_name {
+            type Via = i64;
+        }
+
+        impl ToGodot for *const #class_name {
+            type ToVia<'v> = i64;
+
+            fn to_godot(&self) -> Self::ToVia<'_> {
+                *self as i64
+            }
+        }
+
+        impl FromGodot for *const #class_name {
+            fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
+                Ok(via as Self)
+            }
+        }
+    };
     // note: TypePtr -> ObjectPtr conversion OK?
 
     builtins::GeneratedBuiltin { code: tokens }

godot-core/src/builtin/collections/array.rs

@@ -4,7 +4,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-
+use std::borrow::Borrow;
 use std::fmt;
 use std::marker::PhantomData;
 
@@ -258,26 +258,31 @@ impl<T: ArrayElement> Array<T> {
 
     /// Sets the value at the specified index.
     ///
+    /// `value` uses `Borrow<T>` to accept either by value or by reference.
+    ///
     /// # Panics
     ///
     /// If `index` is out of bounds.
-    pub fn set(&mut self, index: usize, value: &T) {
+    pub fn set(&mut self, index: usize, value: impl Borrow<T>) {
         let ptr_mut = self.ptr_mut(index);
 
+        let variant = value.borrow().to_variant();
+
         // SAFETY: `ptr_mut` just checked that the index is not out of bounds.
-        unsafe {
-            value.to_variant().move_into_var_ptr(ptr_mut);
-        }
+        unsafe { variant.move_into_var_ptr(ptr_mut) };
     }
 
     /// Appends an element to the end of the array.
     ///
+    /// `value` uses `Borrow<T>` to accept either by value or by reference.
+    ///
     /// _Godot equivalents: `append` and `push_back`_
     #[doc(alias = "append")]
     #[doc(alias = "push_back")]
-    pub fn push(&mut self, value: &T) {
+    pub fn push(&mut self, value: impl Borrow<T>) {
         // SAFETY: The array has type `T` and we're writing a value of type `T` to it.
-        unsafe { self.as_inner_mut() }.push_back(&value.to_variant());
+        let mut inner = unsafe { self.as_inner_mut() };
+        inner.push_back(&value.borrow().to_variant());
     }
 
     /// Adds an element at the beginning of the array, in O(n).

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

@@ -91,8 +91,10 @@ where
 impl<T: ToGodot> ToGodot for Option<T>
 where
     Option<T::Via>: GodotType,
+    for<'f> T::ToVia<'f>: GodotType<Ffi: GodotNullableFfi>,
 {
     type ToVia<'v> = Option<T::ToVia<'v>>
+    // type ToVia<'v> = Self::Via
     where Self: 'v;
 
     fn to_godot(&self) -> Self::ToVia<'_> {

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

@@ -40,7 +40,7 @@ pub trait GodotConvert {
 ///
 /// Please read the [`godot::meta` module docs][crate::meta] for further information about conversions.
 pub trait ToGodot: Sized + GodotConvert {
-    type ToVia<'v>
+    type ToVia<'v>: GodotType
     where
         Self: 'v;
 

godot-core/src/meta/ref_arg.rs

@@ -29,7 +29,7 @@ impl<'r, T> ToGodot for RefArg<'r, T>
 where
     T: ToGodot,
 {
-    type ToVia<'v> = Self::Via
+    type ToVia<'v> = T::ToVia<'v>
     where Self: 'v;
 
     fn to_godot(&self) -> Self::ToVia<'_> {

godot-core/src/meta/traits.rs

@@ -38,8 +38,7 @@ pub trait GodotFfiVariant: Sized + GodotFfi {
 // type. For instance [`i32`] does not implement `GodotFfi` because it cannot represent all values of
 // Godot's `int` type, however it does implement `GodotType` because we can set the metadata of values with
 // this type to indicate that they are 32 bits large.
-pub trait GodotType:
-    GodotConvert<Via = Self> + ToGodot + FromGodot + sealed::Sealed + 'static
+pub trait GodotType: GodotConvert<Via = Self> + sealed::Sealed + Sized + 'static
 // 'static is not technically required, but it simplifies a few things (limits e.g. ObjectArg).
 {
     #[doc(hidden)]
@@ -145,7 +144,7 @@ pub trait GodotType:
     message = "`Array<T>` can only store element types supported in Godot arrays (no nesting).",
     label = "has invalid element type"
 )]
-pub trait ArrayElement: GodotType + sealed::Sealed {
+pub trait ArrayElement: GodotType + ToGodot + FromGodot + sealed::Sealed {
     /// Returns the representation of this type as a type string.
     ///
     /// Used for elements in arrays (the latter despite `ArrayElement` not having a direct relation).

godot-macros/src/derive/derive_to_godot.rs

@@ -42,6 +42,9 @@ fn make_togodot_for_newtype_struct(name: &Ident, field: &NewtypeStruct) -> Token
 
     quote! {
         impl ::godot::meta::ToGodot for #name {
+            // For now by-value, may change.
+            type ToVia<'v> = #via_type;
+
             fn to_godot(&self) -> #via_type {
                 ::godot::meta::ToGodot::to_godot(&self.#field_name)
             }
@@ -67,6 +70,8 @@ fn make_togodot_for_int_enum(
 
     quote! {
         impl ::godot::meta::ToGodot for #name {
+            type ToVia<'v> = #int;
+
             #[allow(unused_parens)] // Error "unnecessary parentheses around block return value"; comes from ord expressions like (1 + 2).
             fn to_godot(&self) -> #int {
                 match self {
@@ -86,6 +91,8 @@ fn make_togodot_for_string_enum(name: &Ident, enum_: &CStyleEnum) -> TokenStream
 
     quote! {
         impl ::godot::meta::ToGodot for #name {
+            type ToVia<'v> = ::godot::builtin::GString;
+
             fn to_godot(&self) -> ::godot::builtin::GString {
                 match self {
                     #(

itest/rust/build.rs

@@ -86,9 +86,10 @@ macro_rules! push_newtype {
             }
 
             impl godot::meta::ToGodot for $name {
+                type ToVia<'v> = $T;
+
                 #[allow(clippy::clone_on_copy)]
-                fn to_godot(&self) -> Self::ToVia<'_>
- {
+                fn to_godot(&self) -> Self::ToVia<'_> {
                     self.0.clone()
                 }
             }

itest/rust/src/builtin_tests/containers/array_test.rs

@@ -53,7 +53,7 @@ fn array_from_packed_array() {
     // This tests that the resulting array doesn't secretly have a runtime type assigned to it,
     // which is not reflected in our static type. It would make sense if it did, but Godot decided
     // otherwise: we get an untyped array.
-    array.push(GString::from("hi").to_variant());
+    array.push(&GString::from("hi").to_variant());
     assert_eq!(array, varray![42, "hi"]);
 }
 

itest/rust/src/builtin_tests/convert_test.rs

@@ -106,6 +106,8 @@ impl GodotConvert for ConvertedStruct {
 }
 
 impl ToGodot for ConvertedStruct {
+    type ToVia<'v> = Dictionary;
+
     fn to_godot(&self) -> Self::ToVia<'_> {
         dict! {
             "a": self.a,