Returns the dereferenced type in the exported method

[B-head]

Feature

Add #[export(deref_return)] to allow exported methods to return dereferenced types. This can be used with types that implement Deref traits.

For example.

#[derive(NativeClass)]
#[no_constructor]
struct Foo {
    bar: i32,
    baz: Rc<RefCell<f64>>,
}

#[methods]
impl Foo {
    #[export(deref_return)]
    fn get_bar(&self, _owner: &Reference) -> &i32 {
        &self.bar
    }

    #[export(deref_return)]
    fn get_baz(&self, _owner: &Reference) -> std::cell::Ref<f64> {
        self.baz.borrow()
    }
}

This feature has the following advantages.

• Types such as std::cell::Ref<f64> can be written in the return type signature.
• Clarify that the expoted method is not pass by reference to Godot engine, but converting and passing by value to Godot engine.
• There is no conflict in the implementation of ToVariant Trait.

Incidental changes

Returning a reference without applying deref_return will display the following warning.

warning: use of deprecated macro `::gdnative::export::deprecated_reference_return`: This function does not actually pass by reference to the Godot engine. You can clarify by writing #[export(deref_return)].

Compatibility

The godot_wrap_method! macro is not compatible because its definition has changed. (Can be fixed for compatibility if needed)

[Bromeon]

Thanks for the PR!

Types such as std::cell::Ref<f64> can be written in the return type signature.

Just to understand -- why do you want to do that?

Since GDScript doesn't support such types, it's not immediately clear how the type would be marshalled. I mean this from a perspective that #[export] methods also act as an API to be invoked from GDScript. Wouldn't it be easier to just return f64 as an explicitly copied value?

[B-head]

Just to understand -- why do you want to do that?

Since GDScript doesn't support such types, it's not immediately clear how the type would be marshalled. I mean this from a perspective that #[export] methods also act as an API to be invoked from GDScript. Wouldn't it be easier to just return f64 as an explicitly copied value?

In this example f64, but usually what I want to pass by reference is type like Vec<_>.
To clone large values is costly. Therefore, I do not want to clone it many times.

If the return type is Variant, it avoids cloning twice, but there is no type checking.
Later, when #850 is implemented and the method is used from the Rust side, Variant type is difficult to use with return type.

#[derive(NativeClass)]
#[no_constructor]
struct Foo {
    bar: Rc<RefCell<Vec<i32>>>,
}

#[methods]
impl Foo {
    #[export]
    fn get_bar(&self) -> Variant {
        self.bar.borrow().to_variant()
    }
}

[parasyte]

Is there a reason that #[export] does not support return values that implement ToVariant? Having that capability would solve your need, AFAICT. Even just this is enough to make it work:

diff --git a/gdnative-core/src/export/macros.rs b/gdnative-core/src/export/macros.rs
index 92b3bea..aab3c12 100644
--- a/gdnative-core/src/export/macros.rs
+++ b/gdnative-core/src/export/macros.rs
@@ -56,7 +56,7 @@ macro_rules! godot_wrap_method_inner {
                                     $($pname,)*
                                     $($opt_pname,)*
                                 );
-                                gdnative::core_types::OwnedToVariant::owned_to_variant(ret)
+                                gdnative::core_types::ToVariant::to_variant(&ret)
                             }
                         })
                         .unwrap_or_else(|err| {

But I can only assume there is a reason this wasn't done in the first place. The best reason I can think of is that feels unusual to a Rust programmer because it will implicitly clone from borrows, as in the example below.

#[derive(NativeClass)]
#[no_constructor]
struct Foo {
    bar: Vec<f32>,
}

#[methods]
impl Foo {
    #[export]
    fn get_bar(&self, _base: &Node) -> &[f32] {
        &self.bar
    }
}