Transform process/physics_process methods to support f32 signatures

Author: Bromeon

godot-core/src/obj/traits.rs

@@ -293,7 +293,7 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
     ///
     /// #[godot_api]
     /// impl INode for MyClass {
-    ///     fn process(&mut self, _delta: f64) {
+    ///     fn process(&mut self, _delta: f32) {
     ///         let name = self.base().get_name();
     ///         godot_print!("name is {name}");
     ///     }
@@ -319,7 +319,7 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
     ///
     /// #[godot_api]
     /// impl INode for MyClass {
-    ///     fn process(&mut self, _delta: f64) {
+    ///     fn process(&mut self, _delta: f32) {
     ///         let node = Node::new_alloc();
     ///         // fails because `add_child` requires a mutable reference.
     ///         self.base().add_child(&node);
@@ -362,7 +362,7 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
     ///
     /// #[godot_api]
     /// impl INode for MyClass {
-    ///     fn process(&mut self, _delta: f64) {
+    ///     fn process(&mut self, _delta: f32) {
     ///         let node = Node::new_alloc();
     ///         self.base_mut().add_child(&node);
     ///     }
@@ -387,7 +387,7 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
     ///
     /// #[godot_api]
     /// impl INode for MyClass {
-    ///     fn process(&mut self, _delta: f64) {
+    ///     fn process(&mut self, _delta: f32) {
     ///         self.base_mut().call("other_method", &[]);
     ///     }
     /// }

godot-macros/src/class/data_models/func.rs

@@ -187,8 +187,14 @@ pub struct SignatureInfo {
     pub method_name: Ident,
     pub receiver_type: ReceiverType,
     pub param_idents: Vec<Ident>,
+    /// Parameter types *without* receiver.
     pub param_types: Vec<venial::TypeExpr>,
     pub return_type: TokenStream,
+
+    /// `(original index, new type)` only for changed parameters; empty if no changes.
+    ///
+    /// Index points into original venial tokens (i.e. takes into account potential receiver params).
+    pub modified_param_types: Vec<(usize, venial::TypeExpr)>,
 }
 
 impl SignatureInfo {
@@ -199,6 +205,7 @@ impl SignatureInfo {
             param_idents: vec![],
             param_types: vec![],
             return_type: quote! { () },
+            modified_param_types: vec![],
         }
     }
 
@@ -359,7 +366,8 @@ pub(crate) fn into_signature_info(
     };
 
     let mut next_unnamed_index = 0;
-    for (arg, _) in signature.params.inner {
+    let mut modified_param_types = vec![];
+    for (index, (arg, _)) in signature.params.inner.into_iter().enumerate() {
         match arg {
             venial::FnParam::Receiver(recv) => {
                 if receiver_type == ReceiverType::GdSelf {
@@ -377,8 +385,17 @@ pub(crate) fn into_signature_info(
             }
             venial::FnParam::Typed(arg) => {
                 let ident = maybe_rename_parameter(arg.name, &mut next_unnamed_index);
-                let ty = venial::TypeExpr {
-                    tokens: map_self_to_class_name(arg.ty.tokens, class_name),
+                let ty = match maybe_change_parameter_type(arg.ty, &method_name, index) {
+                    // Parameter type was modified.
+                    Ok(ty) => {
+                        modified_param_types.push((index, ty.clone()));
+                        ty
+                    }
+
+                    // Not an error, just unchanged.
+                    Err(ty) => venial::TypeExpr {
+                        tokens: map_self_to_class_name(ty.tokens, class_name),
+                    },
                 };
 
                 param_types.push(ty);
@@ -393,6 +410,28 @@ pub(crate) fn into_signature_info(
         param_idents,
         param_types,
         return_type: ret_type,
+        modified_param_types,
+    }
+}
+
+/// If `f32` is used for a delta parameter in a virtual process function, transparently use `f64` behind the scenes.
+fn maybe_change_parameter_type(
+    param_ty: venial::TypeExpr,
+    method_name: &Ident,
+    param_index: usize,
+) -> Result<venial::TypeExpr, venial::TypeExpr> {
+    // A bit hackish, but TokenStream APIs are also notoriously annoying to work with. Not even PartialEq...
+
+    if param_index == 1
+        && (method_name == "process" || method_name == "physics_process")
+        && param_ty.tokens.len() == 1
+        && param_ty.tokens[0].to_string() == "f32"
+    {
+        Ok(venial::TypeExpr {
+            tokens: vec![TokenTree::Ident(ident("f64"))],
+        })
+    } else {
+        Err(param_ty)
     }
 }
 

godot-macros/src/class/data_models/interface_trait_impl.rs

@@ -9,7 +9,7 @@ use crate::class::{into_signature_info, make_virtual_callback, BeforeKind, Signa
 use crate::util::ident;
 use crate::{util, ParseResult};
 
-use proc_macro2::{Ident, TokenStream};
+use proc_macro2::{Group, Ident, TokenStream};
 use quote::{quote, ToTokens};
 
 /// Codegen for `#[godot_api] impl ISomething for MyType`.
@@ -71,18 +71,27 @@ pub fn transform_trait_impl(mut original_impl: venial::Impl) -> ParseResult<Toke
             }
             regular_virtual_fn => {
                 // Break borrow chain to allow handle_regular_virtual_fn() to mutably borrow `method` and modify `original_impl` through it.
-                let cfg_attrs = cfg_attrs.iter().cloned().collect();
+                // let cfg_attrs = cfg_attrs.iter().cloned().collect()
 
                 // All the non-special engine ones: ready(), process(), etc.
                 // Can modify original_impl, concretely the fn body for f64->f32 conversions.
-                handle_regular_virtual_fn(
+                let changed_function = handle_regular_virtual_fn(
                     &class_name,
                     &trait_path,
                     method,
                     regular_virtual_fn,
                     cfg_attrs,
                     &mut decls,
                 );
+
+                // If the function is modified (e.g. process() declared with f32), apply changes here.
+                // Borrow-checker: we cannot reassign whole function due to shared borrow on `method.attributes`.
+                // Thus, separately update signature + body when needed.
+                if let Some((new_params, new_body)) = changed_function {
+                    method.params = new_params;
+                    method.body = Some(new_body);
+                    //panic!("modify params: {}", method.params.to_token_stream().to_string());
+                }
             }
         }
     }
@@ -445,14 +454,14 @@ fn handle_property_get_revert<'a>(
 fn handle_regular_virtual_fn<'a>(
     class_name: &Ident,
     trait_path: &venial::TypeExpr,
-    method: &venial::Function,
+    original_method: &venial::Function,
     method_name: &str,
     cfg_attrs: Vec<&'a venial::Attribute>,
     decls: &mut IDecls<'a>,
-) {
+) -> Option<(venial::Punctuated<venial::FnParam>, Group)> {
     #[cfg(since_api = "4.4")]
-    let method_name_ident = method.name.clone();
-    let method = util::reduce_to_signature(method);
+    let method_name_ident = original_method.name.clone();
+    let method = util::reduce_to_signature(original_method);
 
     // Godot-facing name begins with underscore.
     //
@@ -466,6 +475,27 @@ fn handle_regular_virtual_fn<'a>(
 
     let signature_info = into_signature_info(method, class_name, false);
 
+    let mut updated_function = None;
+
+    // If there was a signature change (e.g. f32 -> f64 in process/physics_process), apply to new function tokens.
+    if !signature_info.modified_param_types.is_empty() {
+        let mut new_params = original_method.params.clone();
+        for (index, new_ty) in signature_info.modified_param_types.iter() {
+            let venial::FnParam::Typed(typed) = &mut new_params.inner[*index].0 else {
+                panic!("Unexpected parameter type: {new_params:?}");
+            };
+
+            typed.ty = new_ty.clone();
+        }
+
+        let body = original_method
+            .body
+            .clone()
+            .expect("function must have a body");
+
+        updated_function = Some((new_params, body));
+    }
+
     // Overridden ready() methods additionally have an additional `__before_ready()` call (for OnReady inits).
     let before_kind = if method_name == "ready" {
         BeforeKind::WithBefore
@@ -489,6 +519,8 @@ fn handle_regular_virtual_fn<'a>(
         before_kind,
         interface_trait: Some(trait_path.clone()),
     });
+
+    updated_function
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------

itest/rust/src/engine_tests/codegen_test.rs

@@ -95,6 +95,9 @@ impl IHttpRequest for CodegenTest {
 
     // Test unnamed parameter in virtual function
     fn process(&mut self, _: f64) {}
+
+    // Test auto-cast to f32 parameter in virtual function
+    fn physics_process(&mut self, _delta: f32) {}
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------