#[func] argument passing now uses relaxed conversions

This is consistent with passing in GDScript, as well as varcalls in GDExtension
(passing variants instead of pointers/scalars). Should avoid subtle discrepancies
that currently occur depending on whether a GDScript value is typed or not.

Author: Bromeon

godot-core/src/builtin/variant/mod.rs

@@ -114,6 +114,17 @@ impl Variant {
         try_from_variant_relaxed(self)
     }
 
+    /// Helper function for relaxed variant conversion with panic on failure.
+    /// Similar to [`to()`](Self::to) but uses relaxed conversion rules.
+    pub(crate) fn to_relaxed_or_panic<T, F>(&self, context: F) -> T
+    where
+        T: FromGodot,
+        F: FnOnce() -> String,
+    {
+        self.try_to_relaxed::<T>()
+            .unwrap_or_else(|err| panic!("{}: {err}", context()))
+    }
+
     /// Checks whether the variant is empty (`null` value in GDScript).
     ///
     /// See also [`get_type()`][Self::get_type].

godot-core/src/meta/mod.rs

@@ -67,7 +67,8 @@ pub use uniform_object_deref::UniformObjectDeref;
 
 pub(crate) use array_type_info::ArrayTypeInfo;
 pub(crate) use traits::{
-    element_godot_type_name, ffi_variant_type, element_variant_type, GodotFfiVariant, GodotNullableFfi,
+    element_godot_type_name, element_variant_type, ffi_variant_type, GodotFfiVariant,
+    GodotNullableFfi,
 };
 
 use crate::registry::method::MethodParamOrReturnInfo;

godot-core/src/meta/param_tuple/impls.rs

@@ -93,9 +93,13 @@ macro_rules! unsafe_impl_param_tuple {
                 let mut iter = array.iter();
                 (
                     $(
-                        <$P>::from_variant(
-                            iter.next().unwrap_or_else(|| panic!("ParamTuple: {} access out-of-bounds (len {})", stringify!($p), array.len()))
-                    ),
+                        {
+                            let variant = iter.next().unwrap_or_else(
+                                || panic!("ParamTuple: {} access out-of-bounds (len {})", stringify!($p), array.len()));
+
+                            variant.to_relaxed_or_panic(
+                                || format!("ParamTuple: failed to convert parameter {}", stringify!($p)))
+                        },
                     )*
                 )
             }
@@ -222,7 +226,8 @@ pub(super) unsafe fn varcall_arg<P: FromGodot>(
     // SAFETY: It is safe to dereference `args_ptr` at `N` as a `Variant`.
     let variant_ref = unsafe { Variant::borrow_var_sys(arg) };
 
-    P::try_from_variant(variant_ref)
+    variant_ref
+        .try_to_relaxed::<P>()
         .map_err(|err| CallError::failed_param_conversion::<P>(call_ctx, param_index, err))
 }