Support custom conversions

[Manishearth]

The motivating example for this is protobufs, but this design should be generally useable for any kind of convenience wrappers

This feature is really in two parts. The goal is to support APIs like this:

impl Opaque {
  fn foo(proto: ProtoBuf<MyType>) {..}
  fn bar() -> ProtoBuf<MyType> {..}
}

where ProtoBuf<MyType> is not a diplomat-safe type, but it can be converted to/from a Diplomat-safe type (here, it would be &[u8]/DiplomatSlice<u8>)

Optionally, on the codegen side, it would be nice if these types could also be converted into something better, e.g. in Kotlin perhaps they get converted into MyTypeProto or something.

[Manishearth]

The vague design I have is something like this, which is in two parts:

fn foo(#[diplomat::convert_custom(&[u8], conversion=convert_proto)] proto: ProtoBuf<MyType>) {
    
   let my: &MyType = proto.get(); // potentially fallible

}

In the diplomat macro, this performs conversion-to-&[u8] (and subsequent conversion-to-DiplomatSlice) in the generated C code, using the param_conversion path.

Then, we have some callback convert_proto that takes the ProtoBuf<MyType> token stream

This callback can be specified in the config.toml as a jinja template¹, or as a custom function passed in by people calling diplomat-tool as a library.

One thing to note is that attributes on parameters are not yet stable, and this doesn't work for return types. We may instead wish to do something like:

#[diplomat::convert_custom(&[u8], arg=proto, conversion=convert_proto)] 
fn foo(proto: ProtoBuf<MyType>)

or even

#[diplomat::bridge]
#[diplomat::abi_rename = "foobar_{0}"]
#[diplomat::custom_conversion(pattern = "ProtoBuf<.*>", conversion=convert_proto)]
mod ffi {
  // ..
}

That may be convenient anyway.

Footnotes

1. For a jinja template to work with generics we may need to provide functions for getting the generic arguments. ↩

[Manishearth]

cc @emarteca @maurer @mgeisler

[Manishearth]

Discussion about custom allocators can move to #792