Merge pull request #977 from lilizoey/feature/builtin-varargs

Make builtin methods with varargs get generated

Author: lilizoey

godot-codegen/src/generator/builtins.rs

@@ -262,15 +262,17 @@ fn make_builtin_method_definition(
         )
     };
 
-    // TODO(#382): wait for https://github.com/godot-rust/gdext/issues/382
     let varcall_invocation = quote! {
-        /*<CallSig as VarcallSignatureTuple>::out_class_varcall(
+        let method_bind = sys::builtin_method_table().#fptr_access;
+
+        <CallSig as VarcallSignatureTuple>::out_builtin_ptrcall_varargs(
             method_bind,
+            #builtin_name_str,
             #method_name_str,
             #object_ptr,
             args,
             varargs
-        )*/
+        )
     };
 
     let safety_doc = method_safety_doc(builtin_class.name(), method);
@@ -282,6 +284,7 @@ fn make_builtin_method_definition(
             varcall_invocation,
             ptrcall_invocation,
             is_virtual_required: false,
+            is_varcall_fallible: false,
         },
         safety_doc,
         &TokenStream::new(),

godot-codegen/src/generator/classes.rs

@@ -536,6 +536,7 @@ fn make_class_method_definition(
             varcall_invocation,
             ptrcall_invocation,
             is_virtual_required: false,
+            is_varcall_fallible: true,
         },
         None,
         cfg_attributes,

godot-codegen/src/generator/functions_common.rs

@@ -43,6 +43,7 @@ pub struct FnCode {
     pub varcall_invocation: TokenStream,
     pub ptrcall_invocation: TokenStream,
     pub is_virtual_required: bool,
+    pub is_varcall_fallible: bool,
 }
 
 pub struct FnDefinition {
@@ -207,7 +208,7 @@ pub fn make_function_definition(
         let varcall_invocation = &code.varcall_invocation;
 
         // TODO Utility functions: update as well.
-        if code.receiver.param.is_empty() {
+        if !code.is_varcall_fallible {
             quote! {
                 #maybe_safety_doc
                 #vis #maybe_unsafe fn #primary_fn_name (

godot-codegen/src/generator/utility_functions.rs

@@ -71,6 +71,7 @@ pub(crate) fn make_utility_function_definition(function: &UtilityFunction) -> To
             varcall_invocation,
             ptrcall_invocation,
             is_virtual_required: false,
+            is_varcall_fallible: false,
         },
         None,
         &TokenStream::new(),

godot-codegen/src/generator/virtual_traits.rs

@@ -155,6 +155,7 @@ fn make_virtual_method(method: &ClassMethod) -> Option<TokenStream> {
             varcall_invocation: TokenStream::new(),
             ptrcall_invocation: TokenStream::new(),
             is_virtual_required: method.is_virtual_required(),
+            is_varcall_fallible: true,
         },
         None,
         &TokenStream::new(),

godot-codegen/src/special_cases/codegen_special_cases.rs

@@ -14,9 +14,14 @@ use crate::models::json::{JsonBuiltinMethod, JsonClassMethod, JsonUtilityFunctio
 use crate::special_cases;
 
 pub(crate) fn is_builtin_method_excluded(method: &JsonBuiltinMethod) -> bool {
-    // TODO Fall back to varcall (recent addition in GDExtension API).
-    // See https://github.com/godot-rust/gdext/issues/382.
-    method.is_vararg
+    // The `cfg` below becomes `false` for api > 4.1 so clippy would complain it's always false.
+    #[allow(clippy::needless_bool)]
+    if method.is_vararg {
+        // Support for calling varargs using gdextension were added in 4.2.
+        cfg!(before_api = "4.2")
+    } else {
+        false
+    }
 }
 
 #[cfg(not(feature = "codegen-full"))]

godot-codegen/src/special_cases/special_cases.rs

@@ -343,7 +343,6 @@ pub fn is_class_method_param_required(
 
 /// True if builtin method is excluded. Does NOT check for type exclusion; use [`is_builtin_type_deleted`] for that.
 pub fn is_builtin_method_deleted(_class_name: &TyName, method: &JsonBuiltinMethod) -> bool {
-    // Currently only deleted if codegen.
     codegen_special_cases::is_builtin_method_excluded(method)
 }
 

godot-core/src/meta/signature.rs

@@ -74,6 +74,15 @@ pub trait VarcallSignatureTuple: PtrcallSignatureTuple {
         varargs: &[Variant],
     ) -> Self::Ret;
 
+    unsafe fn out_builtin_ptrcall_varargs(
+        builtin_fn: BuiltinMethodBind,
+        class_name: &'static str,
+        method_name: &'static str,
+        type_ptr: sys::GDExtensionTypePtr,
+        args: Self::Params,
+        varargs: &[Variant],
+    ) -> Self::Ret;
+
     fn format_args(args: &Self::Params) -> String;
 }
 
@@ -303,6 +312,35 @@ macro_rules! impl_varcall_signature_for_tuple {
                 result.unwrap_or_else(|err| return_error::<Self::Ret>(&call_ctx, err))
             }
 
+            #[inline]
+            unsafe fn out_builtin_ptrcall_varargs(
+                builtin_fn: BuiltinMethodBind,
+                class_name: &'static str,
+                method_name: &'static str,
+                type_ptr: sys::GDExtensionTypePtr,
+                ($($pn,)*): Self::Params,
+                varargs: &[Variant],
+            ) -> Self::Ret {
+                let call_ctx = CallContext::outbound(class_name, method_name);
+                //$crate::out!("out_builtin_ptrcall_varargs: {call_ctx}");
+
+                let explicit_args: [Variant; $PARAM_COUNT] = [
+                    $(
+                       into_ffi_variant(&$pn),
+                    )*
+                ];
+
+                let mut type_ptrs = Vec::with_capacity(explicit_args.len() + varargs.len());
+                type_ptrs.extend(explicit_args.iter().map(sys::GodotFfi::sys));
+                type_ptrs.extend(varargs.iter().map(sys::GodotFfi::sys));
+
+                // Important: this calls from_sys_init_default().
+                let result = new_from_ptrcall::<Self::Ret>(|return_ptr| {
+                    builtin_fn(type_ptr, type_ptrs.as_ptr(), return_ptr, type_ptrs.len() as i32);
+                });
+                result.unwrap_or_else(|err| return_error::<Self::Ret>(&call_ctx, err))
+            }
+
             #[inline]
             fn format_args(args: &Self::Params) -> String {
                 let mut string = String::new();

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

@@ -151,6 +151,24 @@ fn callable_bindv() {
     );
 }
 
+// This is also testing that using works at all.
+#[itest]
+#[cfg(since_api = "4.2")]
+fn callable_varargs() {
+    // TODO: Replace with proper apis instead of using `InnerCallable`.
+    use godot::builtin::inner;
+    let obj = CallableTestObj::new_gd();
+    let callable = obj.callable("bar");
+    let inner_callable = inner::InnerCallable::from_outer(&callable);
+    let callable_bound = inner_callable.bind(&[10.to_variant()]);
+    let inner_callable_bound = inner::InnerCallable::from_outer(&callable_bound);
+
+    assert_eq!(
+        inner_callable_bound.call(&[]),
+        10.to_variant().stringify().to_variant()
+    );
+}
+
 // Testing https://github.com/godot-rust/gdext/issues/410
 
 #[derive(GodotClass)]