Improving function pointer/callbacks readability

[pixsperdavid]

Currently, function pointers in generated bindings are named based on their argument types, and are given default argument names (x0, x1, etc). In order to enhance readability, I'd like to add the ability to specify a custom name for a function pointer (or use the name of the rust type alias), and also provide some metadata on names to give the arguments. This would make it far easier to visually parse the declarations in bindings files.

I've played around with a few ways to achieve this, it seems to be that adding an additional macro may be the best approach (e.g. ffi_callback), but would be interested to hear other thoughts, as well as any other points that should be considered when implementing this feature.

[ralfbiedert]

IIRC the issue is that function pointers are anonymous, which means you could only ever name them once on a type level.

For example, you can impl CTypeInfo for fn(u8) -> u8, and then you can select a name (FlipBits), but then any use in any of your Rust API would always become FlipBits, even if you want to use a fn(u8) -> u8 as a ConvertTemp now.

In addition, implementing CTypeInfo for a Rust-native type can only be done in the interoptopus crate, which pretty much prevents any specialized naming.

The only way around that were user-definable custom types, how the current callback / delegate system works.

Type aliases type X = fn(u8) -> u8 are just aliases, you can't add "extra" annotations on them (gives same issue as above, you can't impl CTypeInfo in your crate).

I think best way forward is do something with the callback! macro and the type that it generates for C.

[pixsperdavid]

Interesting, I hadn't attempted using the callback! macro because I had assumed it would generate a wrapper struct in the bindings files. Makes sense. I'll take a look in this direction. After this feature is implemented it may be worth me clarifying the documentation around this macro to indicate this usage for custom naming as well as expressing callbacks which cannot be formatted as standard rust declarations.

[ralfbiedert]

assumed it would generate a wrapper struct in the bindings

Yes-ish. In Rust it's a transparent struct wrapping a single pointer, but as a fallback type it should just generate a vanilla function pointer from that. Backends would either handle it as delegates (C#), or just emit that pointer (C).