Utility functions with "arg1" parameter are now full vararg

Removes the need for manually implementing print() and print_rich()

Author: Bromeon

godot-codegen/src/models/domain_mapping.rs

@@ -486,6 +486,15 @@ impl UtilityFunction {
             return None;
         }
 
+        // Some vararg functions like print() or str() are declared with a single argument "arg1: Variant", but that seems
+        // to be a mistake. We change their parameter list by removing that.
+        let args = option_as_slice(&function.arguments);
+        let parameters = if function.is_vararg && args.len() == 1 && args[0].name == "arg1" {
+            vec![]
+        } else {
+            FnParam::new_range(&function.arguments, ctx)
+        };
+
         let godot_method_name = function.name.clone();
         let rust_method_name = godot_method_name.clone(); // No change for now.
 
@@ -498,7 +507,7 @@ impl UtilityFunction {
             common: FunctionCommon {
                 name: rust_method_name,
                 godot_name: godot_method_name,
-                parameters: FnParam::new_range(&function.arguments, ctx),
+                parameters,
                 return_value: FnReturn::new(&return_value, ctx),
                 is_vararg: function.is_vararg,
                 is_private: false,

godot-codegen/src/special_cases/special_cases.rs

@@ -282,17 +282,13 @@ pub fn is_builtin_type_scalar(name: &str) -> bool {
 
 #[rustfmt::skip]
 pub fn is_utility_function_deleted(function: &JsonUtilityFunction, ctx: &mut Context) -> bool {
-    let hardcoded = match function.name.as_str() {
-        // We have prints manually defined, with (&[Variant]) instead of (Variant, &[Variant]) signature.
-        | "print"
-        | "print_rich"
-        // Should we map str, printt, prints, printerr, printraw manually as well?
+    /*let hardcoded = match function.name.as_str() {
+        | "..."
 
         => true, _ => false
     };
 
-
-    hardcoded || codegen_special_cases::is_utility_function_excluded(function, ctx)
+    hardcoded ||*/ codegen_special_cases::is_utility_function_excluded(function, ctx)
 }
 
 pub fn maybe_rename_class_method<'m>(class_name: &TyName, godot_method_name: &'m str) -> &'m str {

godot-core/src/global/mod.rs

@@ -9,9 +9,9 @@
 //!
 //! See also [Godot docs for `@GlobalScope`](https://docs.godotengine.org/en/stable/classes/class_@globalscope.html#methods).
 
-pub(crate) mod print;
+mod print;
+
+pub use crate::{godot_error, godot_print, godot_print_rich, godot_script_error, godot_warn};
 
 pub use crate::gen::central::global_enums::*;
 pub use crate::gen::utilities::*;
-
-pub use print::*;

godot-core/src/global/print.rs

@@ -105,58 +105,3 @@ macro_rules! godot_print_rich {
         ])
     };
 }
-
-pub use crate::{godot_error, godot_print, godot_print_rich, godot_script_error, godot_warn};
-
-use crate::builtin::{StringName, Variant};
-use crate::sys::{self, GodotFfi};
-
-/// Prints to the Godot console (raw variant args).
-///
-/// Typically, you'd want to use the [`godot_print!`] macro instead, which uses this function internally.
-pub fn print(varargs: &[Variant]) {
-    unsafe {
-        let method_name = StringName::from("print");
-        let call_fn = sys::interface_fn!(variant_get_ptr_utility_function)(
-            method_name.string_sys(),
-            2648703342i64,
-        );
-        let call_fn = call_fn.unwrap_unchecked();
-
-        let mut args = Vec::new();
-        args.extend(varargs.iter().map(Variant::sys));
-
-        let args_ptr = args.as_ptr();
-        let _variant = Variant::new_with_init(|return_ptr| {
-            call_fn(return_ptr, args_ptr, args.len() as i32);
-        });
-    }
-
-    // TODO use generated method, but figure out how print() with zero args can be called
-    // crate::engine::utilities::print(head, rest);
-}
-
-/// Prints rich text to the Godot console (raw variant args).
-///
-/// Typically, you'd want to use the [`godot_print_rich!`] macro instead, which uses this function internally.
-pub fn print_rich(varargs: &[Variant]) {
-    unsafe {
-        let method_name = StringName::from("print_rich");
-        let call_fn = sys::interface_fn!(variant_get_ptr_utility_function)(
-            method_name.string_sys(),
-            2648703342i64,
-        );
-        let call_fn = call_fn.unwrap_unchecked();
-
-        let mut args = Vec::new();
-        args.extend(varargs.iter().map(Variant::sys));
-
-        let args_ptr = args.as_ptr();
-        let _variant = Variant::new_with_init(|return_ptr| {
-            call_fn(return_ptr, args_ptr, args.len() as i32);
-        });
-    }
-
-    // TODO use generated method, but figure out how print_rich() with zero args can be called
-    // crate::engine::utilities::print_rich(head, rest);
-}

godot-core/src/lib.rs

@@ -16,7 +16,9 @@ pub mod obj;
 
 #[deprecated = "Print macros have been moved to `godot::global`."]
 pub mod log {
-    pub use crate::global::print::*;
+    pub use crate::global::{
+        godot_error, godot_print, godot_print_rich, godot_script_error, godot_warn,
+    };
 }
 
 #[doc(hidden)]

itest/rust/src/engine_tests/utilities_test.rs

@@ -7,7 +7,7 @@
 
 use crate::framework::itest;
 
-use godot::builtin::Variant;
+use godot::builtin::{GString, Variant};
 use godot::global::*;
 
 #[itest]
@@ -26,6 +26,21 @@ fn utilities_sign() {
     assert_eq!(output, Variant::from(-1));
 }
 
+#[itest]
+fn utilities_str() {
+    let concat = str(&[
+        Variant::from(12),
+        Variant::from(" is a "),
+        Variant::from(true),
+        Variant::from(" number"),
+    ]);
+
+    let empty = str(&[]);
+
+    assert_eq!(concat, "12 is a true number".into());
+    assert_eq!(empty, GString::new());
+}
+
 #[itest]
 fn utilities_wrap() {
     let output = wrap(Variant::from(3.4), Variant::from(2.0), Variant::from(3.0));