Optional variant list argument for func

[kekobleibtkeko]

I'm trying to get a varying list of arguments passed from gdscript. I couldn't find any other way to make it work than a plain VarArray. When using VarArray, I can't make it optional with #[opt], since Variant isn't GodotImmutable. I'm making this for an mlua API, and having to pass an empty array when no arguments are needed is kinda dumb!

So I'm looking for a way to pass a flexible amount of Variants into Rust (including none at all), in the best case in the same way as a gdscript ... argument.

[Bromeon]

We should probably relax optional arguments in #[func] a bit, the initial version was deliberately conservative.

At the moment we require #[opt(default = ...)], but extending this to types like Variant is problematic, as they can contain anything. We need however a reliable way of either deep-copying the value or making it immutable, so that two subsequent calls get the same default value. (We don't know if the expression creates a new value or returns a shallow-clone of an existing one).

What we can do is provide #[opt] for types implementing Default trait, as described in #1406.

This is safe for cases where the default instance is meaningful, and representing the same value:

• Variant -- nil
• Array<T> (already supported today) -- empty array
• VarDictionary -- empty dict
• maybe even refcounted Gd<T>

Note that the created values aren't necessarily equal (==), as many use shallow ref-equality.

Default-constructing should work. Maybe even caching + cloning is possible, if the value can be made immutable (array/dict) or creates independent copies (variant). It would not work for objects though 🤔

[kekobleibtkeko]

Good to know I didn't at least miss something obvious here!
So for now I'll need to work around this with passing empty arrays on the gdscript side, I suppose?
Oh, and what about functions that can be called like a vararg one, is that something that's planned (or maybe even already possible)?

[Bromeon]

So for now I'll need to work around this with passing empty arrays on the gdscript side, I suppose?

Unfortunately yes... or help implement the feature in godot-rust 😛
I could maybe have a look on the WE how involved it would be.

---

Oh, and what about functions that can be called like a vararg one, is that something that's planned (or maybe even already possible)?

Do you mean calling Godot vararg functions from Rust? This is possible with vslice:

let mut obj: Gd<MyClass>
obj.emit_signal("my_signal", vslice!["hello", 123]);

See e.g. Object API. Of course, in this specific case you'd rather use type-safe signals, but it should illustrate the point:

obj.signals().my_signal().emit("hello", 123);

[kekobleibtkeko]

Helping out feels daunting for me! If you do have a look at the complexity of the task I'll certainly consider it, though. Though as a relatively inexperienced Rust dev I can't make any promises!

---

And the way I meant it was defining a #[func] that lets the gdscript side see it as a vararg function. Essentially actually doing what I'm trying to emulate with the optional VarArray in my current setup.

[Bromeon]

And the way I meant it was defining a #[func] that lets the gdscript side see it as a vararg function.

Ah, I see! Indeed, that's currently not possible -- but it's a good feature request, too.