Special cases for nullability of virtual function parameters

Author: Bromeon

godot-codegen/src/generator/default_parameters.rs

@@ -50,10 +50,10 @@ pub fn make_function_definition_with_defaults(
     let receiver_self = &code.receiver.self_prefix;
 
     let [required_params_impl_asarg, _, _] =
-        functions_common::make_params_exprs(required_fn_params.iter().cloned(), false, true, true);
+        functions_common::make_params_exprs(required_fn_params.iter().cloned(), true, true);
 
     let [_, _, required_args_internal] =
-        functions_common::make_params_exprs(required_fn_params.into_iter(), false, false, false);
+        functions_common::make_params_exprs(required_fn_params.into_iter(), false, false);
 
     let return_decl = &sig.return_value().decl;
 

godot-codegen/src/generator/functions_common.rs

@@ -7,6 +7,7 @@
 
 use crate::generator::default_parameters;
 use crate::models::domain::{FnParam, FnQualifier, Function, RustTy};
+use crate::special_cases;
 use crate::util::safe_ident;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
@@ -119,12 +120,15 @@ pub fn make_function_definition(
         (TokenStream::new(), TokenStream::new())
     };
 
-    let [params, param_types, arg_names] = make_params_exprs(
-        sig.params().iter(),
-        sig.is_virtual(),
-        !has_default_params, // For *_full function, we don't need impl AsObjectArg<T> parameters
-        !has_default_params, // or arg.as_object_arg() calls.
-    );
+    let [params, param_types, arg_names] = if sig.is_virtual() {
+        make_params_exprs_virtual(sig.params().iter(), sig)
+    } else {
+        make_params_exprs(
+            sig.params().iter(),
+            !has_default_params, // For *_full function, we don't need impl AsObjectArg<T> parameters
+            !has_default_params, // or arg.as_object_arg() calls.
+        )
+    };
 
     let rust_function_name_str = sig.name();
 
@@ -202,7 +206,6 @@ pub fn make_function_definition(
             // A function() may call try_function(), its arguments should not have .as_object_arg().
             let [_, _, arg_names_without_asarg] = make_params_exprs(
                 sig.params().iter(),
-                false,
                 !has_default_params, // For *_full function, we don't need impl AsObjectArg<T> parameters
                 false,               // or arg.as_object_arg() calls.
             );
@@ -307,10 +310,9 @@ pub fn make_vis(is_private: bool) -> TokenStream {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Implementation
 
-// Method could possibly be split -- only one invocation uses all 3 return values, the rest uses only index [0] or [2].
+/// For non-virtual functions, returns the parameter declarations, type tokens, and names.
 pub(crate) fn make_params_exprs<'a>(
     method_args: impl Iterator<Item = &'a FnParam>,
-    is_virtual: bool,
     param_is_impl_asarg: bool,
     arg_is_asarg: bool,
 ) -> [Vec<TokenStream>; 3] {
@@ -328,7 +330,7 @@ pub(crate) fn make_params_exprs<'a>(
                 object_arg,
                 impl_as_object_arg,
                 ..
-            } if !is_virtual => {
+            } => {
                 // Parameter declarations in signature: impl AsObjectArg<T>
                 if param_is_impl_asarg {
                     params.push(quote! { #param_name: #impl_as_object_arg });
@@ -346,8 +348,40 @@ pub(crate) fn make_params_exprs<'a>(
                 param_types.push(quote! { #object_arg });
             }
 
+            // All other methods and parameter types: standard handling.
+            _ => {
+                params.push(quote! { #param_name: #param_ty });
+                arg_names.push(quote! { #param_name });
+                param_types.push(quote! { #param_ty });
+            }
+        }
+    }
+
+    [params, param_types, arg_names]
+}
+
+/// For virtual functions, returns the parameter declarations, type tokens, and names.
+pub(crate) fn make_params_exprs_virtual<'a>(
+    method_args: impl Iterator<Item = &'a FnParam>,
+    function_sig: &dyn Function,
+) -> [Vec<TokenStream>; 3] {
+    let mut params = vec![];
+    let mut param_types = vec![]; // or non-generic params
+    let mut arg_names = vec![];
+
+    for param in method_args {
+        let param_name = &param.name;
+        let param_ty = &param.type_;
+
+        match &param.type_ {
             // Virtual methods accept Option<Gd<T>>, since we don't know whether objects are nullable or required.
-            RustTy::EngineClass { .. } if is_virtual => {
+            RustTy::EngineClass { .. }
+                if !special_cases::is_class_method_param_required(
+                    function_sig.surrounding_class().unwrap(),
+                    function_sig.name(),
+                    param_name,
+                ) =>
+            {
                 params.push(quote! { #param_name: Option<#param_ty> });
                 arg_names.push(quote! { #param_name });
                 param_types.push(quote! { #param_ty });

godot-codegen/src/special_cases/special_cases.rs

@@ -28,6 +28,7 @@ use crate::models::domain::{Enum, RustTy, TyName};
 use crate::models::json::{JsonBuiltinMethod, JsonClassMethod, JsonUtilityFunction};
 use crate::special_cases::codegen_special_cases;
 use crate::Context;
+use proc_macro2::Ident;
 // Deliberately private -- all checks must go through `special_cases`.
 
 #[rustfmt::skip]
@@ -269,6 +270,44 @@ pub fn is_class_method_const(class_name: &TyName, godot_method: &JsonClassMethod
     }
 }
 
+/// Currently only for virtual methods; checks if the specified parameter is required (non-null) and can be declared as `Gd<T>`
+/// instead of `Option<Gd<T>>`.
+pub fn is_class_method_param_required(
+    class_name: &TyName,
+    method_name: &str,
+    param: &Ident, // Don't use `&str` to avoid to_string() allocations for each check on call-site.
+) -> bool {
+    // Note: magically, it's enough if a base class method is declared here; it will be picked up by derived classes.
+
+    match (class_name.godot_ty.as_str(), method_name) {
+        // Nodes.
+        ("Node", "input") => true,
+        ("Node", "shortcut_input") => true,
+        ("Node", "unhandled_input") => true,
+        ("Node", "unhandled_key_input") => true,
+
+        // https://docs.godotengine.org/en/stable/classes/class_collisionobject2d.html#class-collisionobject2d-private-method-input-event
+        ("CollisionObject2D", "input_event") => true, // both parameters.
+
+        // UI.
+        ("Control", "gui_input") => true,
+
+        // Script instances.
+        ("ScriptExtension", "instance_create") => param == "for_object",
+        ("ScriptExtension", "placeholder_instance_create") => param == "for_object",
+        ("ScriptExtension", "inherits_script") => param == "script",
+        ("ScriptExtension", "instance_has") => param == "object",
+
+        // Editor.
+        ("EditorExportPlugin", "customize_resource") => param == "resource",
+        ("EditorExportPlugin", "customize_scene") => param == "scene",
+
+        ("EditorPlugin", "handles") => param == "object",
+
+        _ => false,
+    }
+}
+
 /// 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.