tmp commit: makes into sig_info faillible, makes sig_info contain info about default parameters, and misc

Author: Astrale

godot-core/src/registry/method.rs

@@ -59,7 +59,7 @@ 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);

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, KvParser, ParseResult};
 use proc_macro2::{Group, Ident, TokenStream, TokenTree};
 use quote::{format_ident, quote};
 
@@ -126,6 +126,7 @@ pub fn make_method_registration(
         .iter()
         .map(|ident| ident.to_string());
 
+    let default_parameters = extract_default_parameters(&func_definition.signature_info)?;
     // 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 +159,9 @@ pub fn make_method_registration(
                     &[
                         #( #param_ident_strs ),*
                     ],
+                    vec![
+                       #( <#default_parameters as ::godot::meta::AsArg>.to_variant() ),*
+                    ]
                 )
             };
 
@@ -175,6 +179,30 @@ pub fn make_method_registration(
     Ok(registration)
 }
 
+fn extract_default_parameters(sig_info: &SignatureInfo) -> ParseResult<Vec<TokenStream>> {
+    let mut res = vec![];
+    let mut allowed = true;
+    for pd in sig_info.param_defaults.iter().rev() {
+        match pd {
+            Some(tk) if allowed => {
+                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 if allowed => {
+                allowed = false;
+            }
+            Some(tk) if !allowed => {
+                return bail!(
+                    tk,
+                    "opt arguments are only allowed at the end of the argument list."
+                );
+            }
+            _ => (),
+        }
+    }
+    res.reverse();
+    Ok(res)
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Implementation
 
@@ -199,6 +227,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 param_defaults: Vec<Option<TokenStream>>,
 }
 
 impl SignatureInfo {
@@ -210,6 +240,7 @@ impl SignatureInfo {
             param_types: vec![],
             return_type: quote! { () },
             modified_param_types: vec![],
+            param_defaults: vec![],
         }
     }
 
@@ -350,7 +381,7 @@ pub(crate) fn into_signature_info(
     signature: venial::Function,
     class_name: &Ident,
     has_gd_self: bool,
-) -> SignatureInfo {
+) -> ParseResult<SignatureInfo> {
     let method_name = signature.name.clone();
     let mut receiver_type = if has_gd_self {
         ReceiverType::GdSelf
@@ -361,6 +392,8 @@ pub(crate) fn into_signature_info(
     let num_params = signature.params.inner.len();
     let mut param_idents = Vec::with_capacity(num_params);
     let mut param_types = Vec::with_capacity(num_params);
+    let mut param_defaults = Vec::with_capacity(num_params);
+
     let ret_type = match signature.return_ty {
         None => quote! { () },
         Some(ty) => map_self_to_class_name(ty.tokens, class_name),
@@ -398,21 +431,27 @@ pub(crate) fn into_signature_info(
                         tokens: map_self_to_class_name(ty.tokens, class_name),
                     },
                 };
+                let default = match crate::KvParser::parse(&arg.attributes, "opt")? {
+                    None => None,
+                    Some(mut parser) => Some(parser.handle_expr_required("default")?),
+                };
 
                 param_types.push(ty);
                 param_idents.push(ident);
+                param_defaults.push(default);
             }
         }
     }
 
-    SignatureInfo {
+    Ok(SignatureInfo {
         method_name,
         receiver_type,
         param_idents,
         param_types,
         return_type: ret_type,
         modified_param_types,
-    }
+        param_defaults,
+    })
 }
 
 /// If `f32` is used for a delta parameter in a virtual process function, transparently use `f64` behind the scenes.

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

@@ -304,8 +304,11 @@ 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 =
-                    into_signature_info(signature.clone(), class_name, gd_self_parameter.is_some());
+                let signature_info = into_signature_info(
+                    signature.clone(),
+                    class_name,
+                    gd_self_parameter.is_some(),
+                )?;
 
                 // For virtual methods, rename/mangle existing user method and create a new method with the original name,
                 // which performs a dynamic dispatch.