Merge #252 #262 #266

252: Implement `#[func]` for static functions r=Bromeon a=lilizoey

Takes over from #210 

Adds support for static methods in classes.

also replaces tabs with spaces in `signature.rs`.

thanks a lot to `@ttencate!` it was very straightforward to make this work based on what they'd already done.

from what i can tell, there are no static virtual methods. so we dont need to implement support for that. im not sure if there ever will be but it doesn't seem likely to me at least.

it might be worth it to move more of this logic into procedural macros eventually.

closes #175 

262: Correct documentation on Array r=Bromeon a=Mercerenies

Per #151, the struct `TypedArray` has been renamed. This MR updates stale documentation to reflect the new naming scheme.

266: Improve `cargo check` times for incremental changes to `godot-core` r=Bromeon a=lilizoey

On my machine, this change makes the time `cargo check` takes to run go from 48 seconds to 11 seconds when making an incremental change to `godot-core`. in this case tested by adding/removing a single method to/from `Basis`.

I've seen it be as low as 2 seconds sometimes but im not entirely sure why that happens.

Co-authored-by: Thomas ten Cate <[email protected]>
Co-authored-by: Lili Zoey <[email protected]>
Co-authored-by: Silvio Mayolo <[email protected]>

Author: 4 people

godot-codegen/src/class_generator.rs

@@ -294,7 +294,6 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
         #![doc = #module_doc]
 
         use godot_ffi as sys;
-        use crate::engine::*;
         use crate::engine::notify::*;
         use crate::builtin::*;
         use crate::obj::{AsArg, Gd};

godot-codegen/src/util.rs

@@ -283,15 +283,15 @@ fn to_rust_type_uncached(ty: &str, ctx: &mut Context) -> RustTy {
             let enum_ty = make_enum_name(enum_);
 
             RustTy::EngineEnum {
-                tokens: quote! { #module::#enum_ty },
+                tokens: quote! { crate::engine::#module::#enum_ty },
                 surrounding_class: Some(class.to_string()),
             }
         } else {
             // Global enum
             let enum_ty = make_enum_name(qualified_enum);
 
             RustTy::EngineEnum {
-                tokens: quote! { global::#enum_ty },
+                tokens: quote! { crate::engine::global::#enum_ty },
                 surrounding_class: None,
             }
         };
@@ -323,7 +323,7 @@ fn to_rust_type_uncached(ty: &str, ctx: &mut Context) -> RustTy {
     } else {
         let ty = rustify_ty(ty);
         RustTy::EngineClass {
-            tokens: quote! { Gd<#ty> },
+            tokens: quote! { Gd<crate::engine::#ty> },
             class: ty.to_string(),
         }
     }

godot-core/build.rs

@@ -16,4 +16,5 @@ fn main() {
     }
 
     godot_codegen::generate_core_files(gen_path);
+    println!("cargo:rerun-if-changed=build.rs");
 }

godot-core/src/builtin/array.rs

@@ -22,11 +22,11 @@ use sys::{ffi_methods, interface_fn, GodotFfi};
 /// Godot's `Array` can be either typed or untyped.
 ///
 /// An untyped array can contain any kind of [`Variant`], even different types in the same array.
-/// We represent this in Rust as `Array`, which is just a type alias for `TypedArray<Variant>`.
+/// We represent this in Rust as `VariantArray`, which is just a type alias for `Array<Variant>`.
 ///
 /// Godot also supports typed arrays, which are also just `Variant` arrays under the hood, but with
 /// runtime checks that no values of the wrong type are put into the array. We represent this as
-/// `TypedArray<T>`, where the type `T` implements `VariantMetadata`, `FromVariant` and `ToVariant`.
+/// `Array<T>`, where the type `T` implements `VariantMetadata`, `FromVariant` and `ToVariant`.
 ///
 /// # Reference semantics
 ///

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

@@ -22,16 +22,7 @@ pub trait SignatureTuple {
         args_ptr: *const sys::GDExtensionConstVariantPtr,
         ret: sys::GDExtensionVariantPtr,
         err: *mut sys::GDExtensionCallError,
-        func: fn(&C, Self::Params) -> Self::Ret,
-        method_name: &str,
-    );
-
-    unsafe fn varcall_mut<C: GodotClass>(
-        instance_ptr: sys::GDExtensionClassInstancePtr,
-        args_ptr: *const sys::GDExtensionConstVariantPtr,
-        ret: sys::GDExtensionVariantPtr,
-        err: *mut sys::GDExtensionCallError,
-        func: fn(&mut C, Self::Params) -> Self::Ret,
+        func: fn(sys::GDExtensionClassInstancePtr, Self::Params) -> Self::Ret,
         method_name: &str,
     );
 
@@ -41,18 +32,7 @@ pub trait SignatureTuple {
         instance_ptr: sys::GDExtensionClassInstancePtr,
         args_ptr: *const sys::GDExtensionConstTypePtr,
         ret: sys::GDExtensionTypePtr,
-        func: fn(&C, Self::Params) -> Self::Ret,
-        method_name: &str,
-        call_type: sys::PtrcallType,
-    );
-
-    // Note: this method imposes extra bounds on GodotFfi, which may not be implemented for user types.
-    // We could fall back to varcalls in such cases, and not require GodotFfi categorically.
-    unsafe fn ptrcall_mut<C: GodotClass>(
-        instance_ptr: sys::GDExtensionClassInstancePtr,
-        args_ptr: *const sys::GDExtensionConstTypePtr,
-        ret: sys::GDExtensionTypePtr,
-        func: fn(&mut C, Self::Params) -> Self::Ret,
+        func: fn(sys::GDExtensionClassInstancePtr, Self::Params) -> Self::Ret,
         method_name: &str,
         call_type: sys::PtrcallType,
     );
@@ -127,133 +107,104 @@ macro_rules! impl_signature_for_tuple {
 
             #[inline]
             unsafe fn varcall<C : GodotClass>(
-				instance_ptr: sys::GDExtensionClassInstancePtr,
-                args_ptr: *const sys::GDExtensionConstVariantPtr,
-                ret: sys::GDExtensionVariantPtr,
-                err: *mut sys::GDExtensionCallError,
-                func: fn(&C, Self::Params) -> Self::Ret,
-                method_name: &str,
-            ) {
-    	        $crate::out!("varcall: {}", method_name);
-
-                let storage = unsafe { crate::private::as_storage::<C>(instance_ptr) };
-                let instance = storage.get();
-
-                let args = ( $(
-                    {
-                        let variant = unsafe { &*(*args_ptr.offset($n) as *mut Variant) }; // TODO from_var_sys
-                        let arg = <$Pn as FromVariant>::try_from_variant(variant)
-                            .unwrap_or_else(|e| param_error::<$Pn>(method_name, $n, variant));
-
-                        arg
-                    },
-                )* );
-
-				let ret_val = func(&*instance, args);
-                let ret_variant = <$R as ToVariant>::to_variant(&ret_val); // TODO write_sys
-				unsafe {
-                    *(ret as *mut Variant) = ret_variant;
-                    (*err).error = sys::GDEXTENSION_CALL_OK;
-                }
-            }
-
-            #[inline]
-            unsafe fn varcall_mut<C : GodotClass>(
-				instance_ptr: sys::GDExtensionClassInstancePtr,
+                instance_ptr: sys::GDExtensionClassInstancePtr,
                 args_ptr: *const sys::GDExtensionConstVariantPtr,
                 ret: sys::GDExtensionVariantPtr,
                 err: *mut sys::GDExtensionCallError,
-                func: fn(&mut C, Self::Params) -> Self::Ret,
+                func: fn(sys::GDExtensionClassInstancePtr, Self::Params) -> Self::Ret,
                 method_name: &str,
             ) {
-    	        $crate::out!("varcall: {}", method_name);
-
-                let storage = unsafe { crate::private::as_storage::<C>(instance_ptr) };
-                let mut instance = storage.get_mut();
+                $crate::out!("varcall: {}", method_name);
 
-                let args = ( $(
-                    {
-                        let variant = unsafe { &*(*args_ptr.offset($n) as *mut Variant) }; // TODO from_var_sys
-                        let arg = <$Pn as FromVariant>::try_from_variant(variant)
-                            .unwrap_or_else(|e| param_error::<$Pn>(method_name, $n, variant));
+                let args = ($(
+                    unsafe { varcall_arg::<$Pn, $n>(args_ptr, method_name) },
+                )*) ;
 
-                        arg
-                    },
-                )* );
-
-				let ret_val = func(&mut *instance, args);
-                let ret_variant = <$R as ToVariant>::to_variant(&ret_val); // TODO write_sys
-				unsafe {
-                    *(ret as *mut Variant) = ret_variant;
-                    (*err).error = sys::GDEXTENSION_CALL_OK;
-                }
+                varcall_return::<$R>(func(instance_ptr, args), ret, err)
             }
 
             #[inline]
             unsafe fn ptrcall<C : GodotClass>(
-				instance_ptr: sys::GDExtensionClassInstancePtr,
+                instance_ptr: sys::GDExtensionClassInstancePtr,
                 args_ptr: *const sys::GDExtensionConstTypePtr,
                 ret: sys::GDExtensionTypePtr,
-                func: fn(&C, Self::Params) -> Self::Ret,
+                func: fn(sys::GDExtensionClassInstancePtr, Self::Params) -> Self::Ret,
                 method_name: &str,
                 call_type: sys::PtrcallType,
             ) {
                 $crate::out!("ptrcall: {}", method_name);
 
-                let storage = unsafe { crate::private::as_storage::<C>(instance_ptr) };
-                let instance = storage.get();
-
-				let args = ( $(
-                    unsafe {
-                        <$Pn as sys::GodotFuncMarshal>::try_from_arg(
-                            sys::force_mut_ptr(*args_ptr.offset($n)),
-                            call_type
-                        )
-                    }
-                        .unwrap_or_else(|e| param_error::<$Pn>(method_name, $n, &e)),
-                )* );
+                let args = ($(
+                    unsafe { ptrcall_arg::<$Pn, $n>(args_ptr, method_name, call_type) },
+                )*) ;
 
-                let ret_val = func(&*instance, args);
                 // SAFETY:
                 // `ret` is always a pointer to an initialized value of type $R
                 // TODO: double-check the above
-				<$R as sys::GodotFuncMarshal>::try_return(ret_val, ret, call_type)
-                    .unwrap_or_else(|ret_val| return_error::<$R>(method_name, &ret_val));
+                ptrcall_return::<$R>(func(instance_ptr, args), ret, method_name, call_type)
             }
+        }
+    };
+}
 
-            #[inline]
-            unsafe fn ptrcall_mut<C : GodotClass>(
-				instance_ptr: sys::GDExtensionClassInstancePtr,
-                args_ptr: *const sys::GDExtensionConstTypePtr,
-                ret: sys::GDExtensionTypePtr,
-                func: fn(&mut C, Self::Params) -> Self::Ret,
-                method_name: &str,
-                call_type: sys::PtrcallType,
-            ) {
-                $crate::out!("ptrcall: {}", method_name);
+/// Convert the `N`th argument of `args_ptr` into a value of type `P`.
+///
+/// # Safety
+/// - It must be safe to dereference the pointer at `args_ptr.offset(N)` .
+unsafe fn varcall_arg<P: FromVariant, const N: isize>(
+    args_ptr: *const sys::GDExtensionConstVariantPtr,
+    method_name: &str,
+) -> P {
+    let variant = &*(*args_ptr.offset(N) as *mut Variant); // TODO from_var_sys
+    P::try_from_variant(variant)
+        .unwrap_or_else(|_| param_error::<P>(method_name, N as i32, variant))
+}
 
-                let storage = unsafe { crate::private::as_storage::<C>(instance_ptr) };
-                let mut instance = storage.get_mut();
+/// Moves `ret_val` into `ret`.
+///
+/// # Safety
+/// - `ret` must be a pointer to an initialized `Variant`.
+/// - It must be safe to write a `Variant` once to `ret`.
+/// - It must be safe to write a `sys::GDExtensionCallError` once to `err`.
+unsafe fn varcall_return<R: ToVariant>(
+    ret_val: R,
+    ret: sys::GDExtensionConstVariantPtr,
+    err: *mut sys::GDExtensionCallError,
+) {
+    let ret_variant = ret_val.to_variant(); // TODO write_sys
+    *(ret as *mut Variant) = ret_variant;
+    (*err).error = sys::GDEXTENSION_CALL_OK;
+}
 
-				let args = ( $(
-                    unsafe {
-                        <$Pn as sys::GodotFuncMarshal>::try_from_arg(
-                            sys::force_mut_ptr(*args_ptr.offset($n)),
-                            call_type
-                        )
-                    }
-                        .unwrap_or_else(|e| param_error::<$Pn>(method_name, $n, &e)),
-                )* );
+/// Convert the `N`th argument of `args_ptr` into a value of type `P`.
+///
+/// # Safety
+/// - It must be safe to dereference the address at `args_ptr.offset(N)` .
+/// - The pointer at `args_ptr.offset(N)` must follow the safety requirements as laid out in
+///   [`GodotFuncMarshal::try_from_arg`][sys::GodotFuncMarshal::try_from_arg].
+unsafe fn ptrcall_arg<P: sys::GodotFuncMarshal, const N: isize>(
+    args_ptr: *const sys::GDExtensionConstTypePtr,
+    method_name: &str,
+    call_type: sys::PtrcallType,
+) -> P {
+    P::try_from_arg(sys::force_mut_ptr(*args_ptr.offset(N)), call_type)
+        .unwrap_or_else(|e| param_error::<P>(method_name, N as i32, &e))
+}
 
-                let ret_val = func(&mut *instance, args);
-                // SAFETY:
-                // `ret` is always a pointer to an initialized value of type $R
-                // TODO: double-check the above
-				<$R as sys::GodotFuncMarshal>::try_return(ret_val, ret, call_type)
-                    .unwrap_or_else(|ret_val| return_error::<$R>(method_name, &ret_val));
-            }
-        }
-    };
+/// Moves `ret_val` into `ret`.
+///
+/// # Safety
+/// `ret_val`, `ret`, and `call_type` must follow the safety requirements as laid out in
+/// [`GodotFuncMarshal::try_return`](sys::GodotFuncMarshal::try_return).
+unsafe fn ptrcall_return<R: sys::GodotFuncMarshal + std::fmt::Debug>(
+    ret_val: R,
+    ret: sys::GDExtensionTypePtr,
+    method_name: &str,
+    call_type: sys::PtrcallType,
+) {
+    ret_val
+        .try_return(ret, call_type)
+        .unwrap_or_else(|ret_val| return_error::<R>(method_name, &ret_val))
 }
 
 fn param_error<P>(method_name: &str, index: i32, arg: &impl Debug) -> ! {