Support combination of Option + borrowed type + opaque type

[Tienisto]

Describe the bug

I followed the docs in https://cjycode.com/flutter_rust_bridge/guides/types/arbitrary/rust-auto-opaque/overview
and created an optional argument:

#[frb(opaque)]
pub struct MyOpaqueType {
    message: String,
}

pub fn create_opaque(message: String) -> MyOpaqueType {
    MyOpaqueType { message }
}

pub async fn use_opaque(object: Option<&MyOpaqueType>) -> String {
    format!("Message: {}", object.unwrap().message)
}

However, the generated code doesn't compile in Rust:

error[E0308]: mismatched types
   --> src/frb_generated.rs:149:80
    |
149 | ...                   Result::<_, ()>::Ok(crate::api::simple::use_opaque(api_object).await)?;
    |                                           ------------------------------ ^^^^^^^^^^ expected `Option<&MyOpaqueType>`, found `Option<RustOpaqueBase<..., ...>>`
    |                                           |
    |                                           arguments to this function are incorrect
    |
    = note: expected enum `Option<&simple::MyOpaqueType>`
               found enum `Option<RustOpaqueBase<RustAutoOpaqueInner<simple::MyOpaqueType>, frb_generated::MoiArc<RustAutoOpaqueInner<simple::MyOpaqueType>>>>`

In a real world example where I came across this issue, I've found a workaround by writing a method for the struct that calls the actual function: Tienisto/rhttp@efec498

Steps to reproduce

1. Create opaque type
2. Add function that optionally borrows the opaque type
3. See compile error

Logs

Not needed

Expected behavior

No response

Generated binding code

No response

OS

No response

Version of flutter_rust_bridge_codegen

2.3.0

Flutter info

No response

Version of clang++

No response

Additional context

I've created https://github.com/Tienisto/frb-optional-opaque-argument to reproduce the error but the example above should also work

[fzyzcjy]

Yes, looks like this combination of features is not supported yet (feel free to PR! alternatively I may implement this feature later). But the following are supported:

• Option<MyOpaqueType>
• Option<RustAutoOpaque<MyOpaqueType>>
• Option<NonOpaqueType> (which does not need to have & since non-opaque types are always copied)

Anyway, &MyOpaqueType is just syntax sugar of "RustAutoOpaque<MyOpaqueType> + (fancily) borrow it", so I guess using Option<RustAutoOpaque<MyOpaqueType>> may not be a big problem.