Only provide function name to CallContext in debug

Author: lyonbeckers

check.sh

@@ -205,6 +205,9 @@ while [[ $# -gt 0 ]]; do
             echo "$HELP_TEXT"
             exit 0
             ;;
+        --release)
+            extraCargoArgs+=("--release")
+            ;;
         --use-serde)
             extraCargoArgs+=("--features" "serde")
             ;;

godot-codegen/src/generator/classes.rs

@@ -80,10 +80,10 @@ struct GeneratedClassModule {
 }
 
 struct Construction {
-    constructor: TokenStream,
     construct_doc: &'static str,
     final_doc: Option<&'static str>,
     godot_default_impl: TokenStream,
+    singleton_impl: TokenStream,
 }
 
 fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClass {
@@ -102,10 +102,10 @@ fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClas
     };
 
     let Construction {
-        constructor,
         construct_doc,
         final_doc,
         godot_default_impl,
+        singleton_impl,
     } = make_constructor_and_default(class, ctx);
 
     let mut extended_class_doc = construct_doc.replace("Self", &class_name.rust_ty.to_string());
@@ -234,7 +234,7 @@ fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClas
             #interface_trait
             #notification_enum
             impl #class_name {
-                #constructor
+                // Constructors all through traits: NewGd, NewAlloc, Singleton.
                 #methods
                 #notify_methods
                 #internal_methods
@@ -267,6 +267,7 @@ fn make_class(class: &Class, ctx: &mut Context, view: &ApiView) -> GeneratedClas
             )*
 
             #godot_default_impl
+            #singleton_impl
             #deref_impl
             #inherits_macro_code
         }
@@ -424,34 +425,18 @@ fn make_constructor_and_default(class: &Class, ctx: &Context) -> Construction {
     // Note: this could use class_id() but is not yet done due to potential future lazy-load refactoring.
     //let class_name_obj = quote! { <Self as crate::obj::GodotClass>::class_id() };
 
-    let (constructor, construct_doc, has_godot_default_impl);
+    let (construct_doc, has_godot_default_impl);
     if ctx.is_singleton(class_name) {
-        // Note: we cannot return &'static mut Self, as this would be very easy to mutably alias.
-        // &'static Self would be possible, but we would lose the whole mutability information (even if that is best-effort and
-        // not strict Rust mutability, it makes the API much more usable).
-        // As long as the user has multiple Gd smart pointers to the same singletons, only the internal raw pointers are aliased.
-        // See also Deref/DerefMut impl for Gd.
-        constructor = quote! {
-            pub fn singleton() -> Gd<Self> {
-                unsafe {
-                    let __class_name = #godot_class_stringname;
-                    let __object_ptr = sys::interface_fn!(global_get_singleton)(__class_name.string_sys());
-                    Gd::from_obj_sys(__object_ptr)
-                }
-            }
-        };
         construct_doc = "# Singleton\n\n\
-            This class is a singleton. You can get the one instance using [`Self::singleton()`][Self::singleton].";
+            This class is a singleton. You can get the one instance using [`Singleton::singleton()`][crate::obj::Singleton::singleton].";
         has_godot_default_impl = false;
     } else if !class.is_instantiable {
         // Abstract base classes or non-singleton classes without constructor.
-        constructor = TokenStream::new();
         construct_doc = "# Not instantiable\n\nThis class cannot be constructed. Obtain `Gd<Self>` instances via Godot APIs.";
         has_godot_default_impl = false;
     } else {
         // Manually managed classes (Object, Node, ...) as well as ref-counted ones (RefCounted, Resource, ...).
         // The constructors are provided as associated methods in NewGd::new_gd() and NewAlloc::new_alloc().
-        constructor = TokenStream::new();
 
         if class.is_refcounted {
             construct_doc = "# Construction\n\n\
@@ -488,11 +473,25 @@ fn make_constructor_and_default(class: &Class, ctx: &Context) -> Construction {
         TokenStream::new()
     };
 
+    let singleton_impl = if ctx.is_singleton(class_name) {
+        let class_name = &class.name().rust_ty;
+        quote! {
+            impl crate::obj::Singleton for #class_name {
+                fn singleton() -> crate::obj::Gd<Self> {
+                    // SAFETY: Class name matches type T, per code generator.
+                    unsafe { crate::classes::singleton_unchecked(&#godot_class_stringname) }
+                }
+            }
+        }
+    } else {
+        TokenStream::new()
+    };
+
     Construction {
-        constructor,
         construct_doc,
         final_doc,
         godot_default_impl,
+        singleton_impl,
     }
 }
 
@@ -573,8 +572,6 @@ fn make_class_method_definition(
         return FnDefinition::none();
     };
 
-    // Note: parameter type replacements (int -> enum) are already handled during domain mapping.
-
     let rust_class_name = class.name().rust_ty.to_string();
     let rust_method_name = method.name();
     let godot_method_name = method.godot_name();

godot-core/src/builtin/callable.rs

@@ -13,7 +13,7 @@ use sys::{ffi_methods, ExtVariantType, GodotFfi};
 use crate::builtin::{inner, GString, StringName, Variant, VariantArray};
 use crate::meta::{GodotType, ToGodot};
 use crate::obj::bounds::DynMemory;
-use crate::obj::{Bounds, Gd, GodotClass, InstanceId};
+use crate::obj::{Bounds, Gd, GodotClass, InstanceId, Singleton};
 use crate::{classes, meta};
 
 #[cfg(before_api = "4.3")]
@@ -72,7 +72,7 @@ impl Callable {
     /// If the builtin type does not have the method, the returned callable will be invalid.
     ///
     /// Static builtin methods (e.g. `String.humanize_size`) are not supported in reflection as of Godot 4.4. For static _class_ functions,
-    /// use [`from_local_static()`][Self::from_local_static] instead.
+    /// use [`from_class_static()`][Self::from_class_static] instead.
     ///
     /// _Godot equivalent: `Callable.create(Variant variant, StringName method)`_
     #[cfg(since_api = "4.3")]
@@ -84,17 +84,15 @@ impl Callable {
         inner::InnerCallable::create(variant, method_name)
     }
 
-    /// Create a callable for the static method `class_name::function` (single-threaded).
+    /// Create a callable for the static method `class_name::function`
     ///
-    /// Allows you to call static functions through `Callable`.
+    /// Allows you to call static functions through `Callable`. Allows both single- and multi-threaded calls; what happens on Godot side
+    /// is your responsibility.
     ///
-    /// Does not support built-in types (such as `String`), only classes.
-    ///
-    /// # Compatibility
-    /// Not available before Godot 4.4. Library versions <0.3 used to provide this, however the polyfill used to emulate it was half-broken
-    /// (not supporting signals, bind(), method_name(), is_valid(), etc).
+    /// Does not support built-in types (such as `String`), only classes. Static functions on built-in types are not supported in Godot's
+    /// reflection APIs at the moment.
     #[cfg(since_api = "4.4")]
-    pub fn from_local_static(
+    pub fn from_class_static(
         class_name: impl meta::AsArg<StringName>,
         function_name: impl meta::AsArg<StringName>,
     ) -> Self {
@@ -103,16 +101,33 @@ impl Callable {
 
         let callable_name = format!("{class_name}.{function_name}");
 
-        Self::from_local_fn(&callable_name, move |args| {
+        let function = move |args: &[&Variant]| {
             let args = args.iter().cloned().cloned().collect::<Vec<_>>();
 
             let result: Variant = classes::ClassDb::singleton().class_call_static(
                 &class_name,
                 &function_name,
                 args.as_slice(),
             );
-            Ok(result)
-        })
+            result
+        };
+
+        #[cfg(feature = "experimental-threads")]
+        let callable = Self::from_sync_fn(&callable_name, function);
+
+        #[cfg(not(feature = "experimental-threads"))]
+        let callable = Self::from_local_fn(&callable_name, function);
+
+        callable
+    }
+
+    #[deprecated = "Renamed to `from_class_static`."]
+    #[cfg(since_api = "4.4")]
+    pub fn from_local_static(
+        class_name: impl meta::AsArg<StringName>,
+        function_name: impl meta::AsArg<StringName>,
+    ) -> Self {
+        Self::from_class_static(class_name, function_name)
     }
 
     fn default_callable_custom_info() -> CallableCustomInfo {
@@ -139,14 +154,15 @@ impl Callable {
     ///
     /// This constructor only allows the callable to be invoked from the same thread as creating it. If you need to invoke it from any thread,
     /// use [`from_sync_fn`][Self::from_sync_fn] instead (requires crate feature `experimental-threads`; only enable if really needed).
-    pub fn from_local_fn<F, S>(name: S, rust_function: F) -> Self
+    pub fn from_local_fn<R, F, S>(name: S, rust_function: F) -> Self
     where
-        F: 'static + FnMut(&[&Variant]) -> Result<Variant, ()>,
+        R: ToGodot,
+        F: 'static + FnMut(&[&Variant]) -> R,
         S: meta::AsArg<GString>,
     {
         meta::arg_into_owned!(name);
 
-        Self::from_fn_wrapper(FnWrapper {
+        Self::from_fn_wrapper::<F, R>(FnWrapper {
             rust_function,
             name,
             thread_id: Some(std::thread::current().id()),
@@ -165,12 +181,12 @@ impl Callable {
     pub fn from_linked_fn<F, T, S>(name: S, linked_object: &Gd<T>, rust_function: F) -> Self
     where
         T: GodotClass,
-        F: 'static + FnMut(&[&Variant]) -> Result<Variant, ()>,
+        F: 'static + FnMut(&[&Variant]) -> Variant,
         S: meta::AsArg<GString>,
     {
         meta::arg_into_owned!(name);
 
-        Self::from_fn_wrapper(FnWrapper {
+        Self::from_fn_wrapper::<F, Variant>(FnWrapper {
             rust_function,
             name,
             thread_id: Some(std::thread::current().id()),
@@ -184,9 +200,10 @@ impl Callable {
     ///
     /// After the first invocation, subsequent calls will panic with a message indicating the callable has already been consumed. This is
     /// useful for deferred operations that should only execute once. For repeated execution, use [`from_local_fn()][Self::from_local_fn].
-    pub(crate) fn from_once_fn<F, S>(name: S, rust_function: F) -> Self
+    pub(crate) fn from_once_fn<R, F, S>(name: S, rust_function: F) -> Self
     where
-        F: 'static + FnOnce(&[&Variant]) -> Result<Variant, ()>,
+        R: ToGodot,
+        F: 'static + FnOnce(&[&Variant]) -> R,
         S: meta::AsArg<GString>,
     {
         meta::arg_into_owned!(name);
@@ -196,6 +213,7 @@ impl Callable {
             let rust_fn_once = rust_fn_once
                 .take()
                 .expect("callable created with from_once_fn() has already been consumed");
+
             rust_fn_once(args)
         })
     }
@@ -204,7 +222,7 @@ impl Callable {
     #[doc(hidden)]
     pub fn __once_fn<F, S>(name: S, rust_function: F) -> Self
     where
-        F: 'static + FnOnce(&[&Variant]) -> Result<Variant, ()>,
+        F: 'static + FnOnce(&[&Variant]) -> Variant,
         S: meta::AsArg<GString>,
     {
         Self::from_once_fn(name, rust_function)
@@ -213,12 +231,12 @@ impl Callable {
     pub(crate) fn with_scoped_fn<S, F, Fc, R>(name: S, rust_function: F, callable_usage: Fc) -> R
     where
         S: meta::AsArg<GString>,
-        F: FnMut(&[&Variant]) -> Result<Variant, ()>,
+        F: FnMut(&[&Variant]) -> Variant,
         Fc: FnOnce(&Callable) -> R,
     {
         meta::arg_into_owned!(name);
 
-        let callable = Self::from_fn_wrapper(FnWrapper {
+        let callable = Self::from_fn_wrapper::<F, Variant>(FnWrapper {
             rust_function,
             name,
             thread_id: Some(std::thread::current().id()),
@@ -248,14 +266,15 @@ impl Callable {
     /// });
     /// ```
     #[cfg(feature = "experimental-threads")]
-    pub fn from_sync_fn<F, S>(name: S, rust_function: F) -> Self
+    pub fn from_sync_fn<R, F, S>(name: S, rust_function: F) -> Self
     where
-        F: 'static + Send + Sync + FnMut(&[&Variant]) -> Result<Variant, ()>,
+        R: ToGodot,
+        F: 'static + Send + Sync + FnMut(&[&Variant]) -> R,
         S: meta::AsArg<GString>,
     {
         meta::arg_into_owned!(name);
 
-        Self::from_fn_wrapper(FnWrapper {
+        Self::from_fn_wrapper::<F, R>(FnWrapper {
             rust_function,
             name,
             thread_id: None,
@@ -287,9 +306,10 @@ impl Callable {
         Self::from_custom_info(info)
     }
 
-    fn from_fn_wrapper<F>(inner: FnWrapper<F>) -> Self
+    fn from_fn_wrapper<F, R>(inner: FnWrapper<F>) -> Self
     where
-        F: FnMut(&[&Variant]) -> Result<Variant, ()>,
+        F: FnMut(&[&Variant]) -> R,
+        R: ToGodot,
     {
         let object_id = inner.linked_object_id();
 
@@ -298,7 +318,7 @@ impl Callable {
         let info = CallableCustomInfo {
             object_id,
             callable_userdata: Box::into_raw(Box::new(userdata)) as *mut std::ffi::c_void,
-            call_func: Some(rust_callable_call_fn::<F>),
+            call_func: Some(rust_callable_call_fn::<F, R>),
             free_func: Some(rust_callable_destroy::<FnWrapper<F>>),
             to_string_func: Some(rust_callable_to_string_named::<F>),
             is_valid_func: Some(rust_callable_is_valid),
@@ -593,7 +613,7 @@ mod custom_callable {
         /// Return `Ok(...)` if the call succeeded, and `Err(())` otherwise.
         /// Error handling is mostly needed in case argument number or types mismatch.
         #[allow(clippy::result_unit_err)] // TODO remove once there's a clear error type here.
-        fn invoke(&mut self, args: &[&Variant]) -> Result<Variant, ()>;
+        fn invoke(&mut self, args: &[&Variant]) -> Variant;
 
         // TODO(v0.3): add object_id().
 
@@ -616,37 +636,44 @@ mod custom_callable {
     ) {
         let arg_refs: &[&Variant] = Variant::borrow_ref_slice(p_args, p_argument_count as usize);
 
-        let name = {
+        #[cfg(debug_assertions)]
+        let name = &{
             let c: &C = CallableUserdata::inner_from_raw(callable_userdata);
             c.to_string()
         };
-        let ctx = meta::CallContext::custom_callable(name.as_str());
+        #[cfg(not(debug_assertions))]
+        let name = "<optimized out>";
+        let ctx = meta::CallContext::custom_callable(name);
 
         crate::private::handle_varcall_panic(&ctx, &mut *r_error, move || {
             // Get the RustCallable again inside closure so it doesn't have to be UnwindSafe.
             let c: &mut C = CallableUserdata::inner_from_raw(callable_userdata);
             let result = c.invoke(arg_refs);
-            meta::varcall_return_checked(result, r_return, r_error);
+            meta::varcall_return_checked(Ok(result), r_return, r_error);
             Ok(())
         });
     }
 
-    pub unsafe extern "C" fn rust_callable_call_fn<F>(
+    pub unsafe extern "C" fn rust_callable_call_fn<F, R>(
         callable_userdata: *mut std::ffi::c_void,
         p_args: *const sys::GDExtensionConstVariantPtr,
         p_argument_count: sys::GDExtensionInt,
         r_return: sys::GDExtensionVariantPtr,
         r_error: *mut sys::GDExtensionCallError,
     ) where
-        F: FnMut(&[&Variant]) -> Result<Variant, ()>,
+        F: FnMut(&[&Variant]) -> R,
+        R: ToGodot,
     {
         let arg_refs: &[&Variant] = Variant::borrow_ref_slice(p_args, p_argument_count as usize);
 
-        let name = {
+        #[cfg(debug_assertions)]
+        let name = &{
             let w: &FnWrapper<F> = CallableUserdata::inner_from_raw(callable_userdata);
             w.name.to_string()
         };
-        let ctx = meta::CallContext::custom_callable(name.as_str());
+        #[cfg(not(debug_assertions))]
+        let name = "<optimized out>";
+        let ctx = meta::CallContext::custom_callable(name);
 
         crate::private::handle_varcall_panic(&ctx, &mut *r_error, move || {
             // Get the FnWrapper again inside closure so the FnMut doesn't have to be UnwindSafe.
@@ -664,8 +691,8 @@ mod custom_callable {
                 );
             }
 
-            let result = (w.rust_function)(arg_refs);
-            meta::varcall_return_checked(result, r_return, r_error);
+            let result = (w.rust_function)(arg_refs).to_variant();
+            meta::varcall_return_checked(Ok(result), r_return, r_error);
             Ok(())
         });
     }