question about impl Trait as arg

[huang12zheng]

input:

impl ISurreal {
    #[tokio::main(flavor = "current_thread")]
    pub async fn set(&self, key: String, value: impl Serialize) -> anyhow::Result<()> {
        Ok(self.get_opaque().set(key, value).await.unwrap())
    }
    // #[tokio::main(flavor = "current_thread")]
    // pub async fn set(&self, key: String, value: SerEnum) -> anyhow::Result<()> {
    //     Ok(self.get_opaque().set(key, value).await.unwrap())
    // }
}

would get error

thread 'main' panicked at 'Failed to parse function argument type `implSerialize`', /Users/huangzheng/rusts/flutter_rust_bridge/frb_codegen/src/parser/mod.rs:127:21

---

so,

How do I use functions with the `impl Trait` as an argument?

Is it in the following way?

#[tokio::main(flavor = "current_thread")]
    pub async fn set(&self, key: String, value: SerEnum) -> anyhow::Result<()> {
         Ok(self.get_opaque().set(key, value).await.unwrap())
    }
impl<'a> Serialize for SerEnum<'a> {
    fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            SerEnum::Root(ref __field0) => __serializer.serialize_newtype_struct("Root", __field0),
            SerEnum::Record(ref __field0) => {
                __serializer.serialize_newtype_struct("Record", __field0)
            }
        }
    }
}

• more info
  a error case(you can ignore)

#[derive(Debug, Serialize)]
pub struct Root<'a> {
    /// The username of the root user
    #[serde(rename = "user")]
    pub username: &'a str,
    /// The password of the root user
    #[serde(rename = "pass")]
    pub password: &'a str,
}

#[derive(Debug, Serialize)]
pub struct Record<'a> {
    pub name: &'a str,
}

// #[derive(Debug, Serialize)]
pub enum SerEnum<'a> {
    Root(Root<'a>),
    Record(Record<'a>),
}

make it to a correct one:

#[derive(Debug, Serialize)]
pub struct Root {
    /// The username of the root user
    #[serde(rename = "user")]
    pub username: String,
    /// The password of the root user
    #[serde(rename = "pass")]
    pub password: String,
}

#[derive(Debug, Serialize)]
pub struct Record {
    pub name: String,
}
pub enum SerEnum {
    Root(Root),
    Record(Record),
}

[fzyzcjy]

IIRC impl as arg is not supported yet, since args must be normal types instead of such generic. Feel free to PR!

[huang12zheng]

But with Enum, you can do it.
This method will generate the following

Future<void> setMethodISurreal({required ISurreal that, required String key, required SerEnum value, dynamic hint}) {
  var arg0 = _platform.api2wire_box_autoadd_i_surreal(that);
  var arg1 = _platform.api2wire_String(key);
  var arg2 = _platform.api2wire_box_autoadd_ser_enum(value);
  return _platform.executeNormal(FlutterRustBridgeTask(
    callFfi: (port_) => _platform.inner.wire_set__method__ISurreal(port_, arg0, arg1, arg2),
    parseSuccessData: _wire2api_unit,
    constMeta: kSetMethodISurrealConstMeta,
    argValues: [that, key, value],
    hint: hint,
  ));
}

@freezed
class SerEnum with _$SerEnum {
  const factory SerEnum.root(
    Root field0,
  ) = SerEnum_Root;
  const factory SerEnum.record(
    Record field0,
  ) = SerEnum_Record;
}

class Root {
  /// The username of the root user
  final String username;

  /// The password of the root user
  final String password;

  Root({
    required this.username,
    required this.password,
  });
}

All I can do is pr the document, because I can only know how many structs I actually use in api.rs that implement traits.
As you can see above, we only pass (obj with trait) wrap with Enum

[huang12zheng]

If someone have another answer, please send it.

[fzyzcjy]

Hmm, please show the code about the enum. <'a> is not the generic I mentioned above. I mean generic except for lifetime specifiers.

[huang12zheng]

Hmm, please show the code about the enum. <'a> is not the generic I mentioned above. I mean generic except for lifetime specifiers.

sorry for it. I replace it with String to work
I would do a patch later.

---

Also, it occurred to me that if I searched all api.rs., I should also be able to find out the corresponding objects for all traits.
It makes me feel very imaginative

[huang12zheng]

through repo https://github.com/huang12zheng/flutter_rust_bridge/tree/debug with Very dirty and ugly code
I could gen enum with impl trait.

use crate::api::*;
use serde::{Serialize, Serializer};
pub enum SerializeEnum {
    Record(Record),
    SerEnum(SerEnum),
}
impl Serialize for SerializeEnum {
    fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            SerializeEnum::Record(ref __field0) => __field0.serialize(__serializer),
            SerializeEnum::SerEnum(ref __field0) => __field0.serialize(__serializer),
        }
    }
}

it happen in https://github.com/huang12zheng/flutter_rust_bridge/blob/debug/frb_codegen/src/utils.rs#L168

but There are still a lot of error in bridge_generated. -_-||

• one in bridge_generated.rs

fn wire_tt_impl(port_: MessagePort, t: impl Wire2Api<Serialize> + UnwindSafe) {

need to be

fn wire_tt_impl(port_: MessagePort, t: impl Wire2Api<SerializeEnum> + UnwindSafe) {

• two in bridge_generated.rs
  bridge_generated add use crate::bridge_generated_bound::*;

• tree in bridge_generated.io.rs

pub extern "C" fn wire_tt(port_: i64, t: wire_Serialize) {

to

pub extern "C" fn wire_tt(port_: i64, t: wire_SerializeEnum) {

• four which is I don't know how to do that yet.
  How do I generate rust and dart code with SerializeEnum.

[huang12zheng]

Looking for places to realize traits,
And where trait bounds are used.

Each trait cound generates a corresponding entity enum.
Implement corresponding trait for these enum