adds default parameters parsing

Author: astrale-sharp

godot-core/src/registry/method.rs

@@ -59,12 +59,11 @@ impl ClassMethodInfo {
         ptrcall_func: sys::GDExtensionClassMethodPtrCall,
         method_flags: MethodFlags,
         param_names: &[&str],
-        // default_arguments: Vec<Variant>, - not yet implemented
+        default_arguments: Vec<Variant>,
     ) -> Self {
         let return_value = Ret::Via::return_info();
         let arguments = Signature::<Params, Ret>::param_names(param_names);
 
-        let default_arguments = vec![]; // not yet implemented.
         assert!(
             default_arguments.len() <= arguments.len(),
             "cannot have more default arguments than arguments"

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

@@ -7,7 +7,7 @@
 
 use crate::class::RpcAttr;
 use crate::util::{bail_fn, ident, safe_ident};
-use crate::{util, ParseResult};
+use crate::{bail, util, ParseResult};
 use proc_macro2::{Group, Ident, TokenStream, TokenTree};
 use quote::{format_ident, quote};
 
@@ -126,6 +126,10 @@ pub fn make_method_registration(
         .iter()
         .map(|ident| ident.to_string());
 
+    let default_parameters =
+        validate_default_parameters(&func_definition.signature_info.default_parameters)?;
+
+    let default_parameter_types = ();
     // Transport #[cfg] attrs to the FFI glue to ensure functions which were conditionally
     // removed from compilation don't cause errors.
     let cfg_attrs = util::extract_cfg_attrs(&func_definition.external_attributes)
@@ -158,6 +162,9 @@ pub fn make_method_registration(
                     &[
                         #( #param_ident_strs ),*
                     ],
+                    vec![
+                        #(::godot::builtin::Variant::from(#default_parameters)),*
+                    ]
                 )
             };
 
@@ -175,6 +182,32 @@ pub fn make_method_registration(
     Ok(registration)
 }
 
+fn validate_default_parameters(
+    default_parameters: &[Option<TokenStream>],
+) -> ParseResult<Vec<TokenStream>> {
+    let mut res = vec![];
+    let mut allowed = true;
+    for param in default_parameters.iter().rev() {
+        match (param, allowed) {
+            (Some(tk), true) => {
+                res.push(tk.clone()); // toreview: if we really care about it, we can use &mut sig_info and mem::take() as we don't use this later
+            }
+            (None, true) => {
+                allowed = false;
+            }
+            (None, false) => {}
+            (Some(tk), false) => {
+                return bail!(
+                    tk,
+                    "opt arguments are only allowed at the end of the argument list."
+                );
+            }
+        }
+    }
+    res.reverse();
+    Ok(res)
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Implementation
 
@@ -199,6 +232,8 @@ pub struct SignatureInfo {
     ///
     /// Index points into original venial tokens (i.e. takes into account potential receiver params).
     pub modified_param_types: Vec<(usize, venial::TypeExpr)>,
+    /// Contains expressions of the default values of parameters.
+    pub default_parameters: Vec<Option<TokenStream>>,
 }
 
 impl SignatureInfo {
@@ -210,6 +245,7 @@ impl SignatureInfo {
             param_types: vec![],
             return_type: quote! { () },
             modified_param_types: vec![],
+            default_parameters: vec![],
         }
     }
 
@@ -412,6 +448,7 @@ pub(crate) fn into_signature_info(
         param_types,
         return_type: ret_type,
         modified_param_types,
+        default_parameters: vec![],
     }
 }
 

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

@@ -304,9 +304,10 @@ fn process_godot_fns(
                 };
 
                 // Clone might not strictly be necessary, but the 2 other callers of into_signature_info() are better off with pass-by-value.
-                let signature_info =
+                let mut signature_info =
                     into_signature_info(signature.clone(), class_name, gd_self_parameter.is_some());
 
+                signature_info.default_parameters = parse_default_parameters(&mut function.params)?;
                 // For virtual methods, rename/mangle existing user method and create a new method with the original name,
                 // which performs a dynamic dispatch.
                 let registered_name = if func.is_virtual {
@@ -688,6 +689,24 @@ fn parse_constant_attr(
     Ok(AttrParseResult::Constant(attr.value.clone()))
 }
 
+fn parse_default_parameters(
+    params: &mut venial::Punctuated<venial::FnParam>,
+) -> ParseResult<Vec<Option<TokenStream>>> {
+    let mut res = vec![];
+    for param in params.iter_mut() {
+        let typed_param = match &mut param.0 {
+            venial::FnParam::Receiver(_) => continue,
+            venial::FnParam::Typed(fn_typed_param) => fn_typed_param,
+        };
+        let default = match KvParser::parse_remove(&mut typed_param.attributes, "opt")? {
+            None => None,
+            Some(mut parser) => Some(parser.handle_expr_required("default")?),
+        };
+        res.push(default);
+    }
+    Ok(res)
+}
+
 fn bail_attr<R>(attr_name: &Ident, msg: &str, method_name: &Ident) -> ParseResult<R> {
     bail!(method_name, "#[{attr_name}]: {msg}")
 }

itest/rust/src/register_tests/default_parameters_test.rs

@@ -0,0 +1,17 @@
+use godot::prelude::*;
+
+#[derive(GodotClass)]
+#[class(no_init)]
+struct HasDefaultParameters {}
+
+#[godot_api]
+impl HasDefaultParameters {
+    #[func]
+    fn function_with_default_params(
+        required: i32,
+        #[opt(default = "test")] string: GString,
+        // #[opt(default = 123)] integer: i32,
+        // #[opt(default=None)] object: Option<Gd<Node>>,
+    ) {
+    }
+}

itest/rust/src/register_tests/mod.rs

@@ -7,6 +7,7 @@
 
 mod constant_test;
 mod conversion_test;
+mod default_parameters_test;
 mod derive_godotconvert_test;
 mod func_test;
 mod gdscript_ffi_test;