Support &dyn Trait

frb_codegen/assets/integration_template/REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.io.rs

@@ -5,7 +5,7 @@
 
 use super::*;
 use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
-use flutter_rust_bridge::for_generated::transform_result_dco;
+use flutter_rust_bridge::for_generated::{transform_result_dco, Lockable};
 use flutter_rust_bridge::{Handler, IntoIntoDart};
 
 // Section: boilerplate

frb_codegen/assets/integration_template/REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.rs

@@ -22,7 +22,7 @@
 // Section: imports
 
 use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
-use flutter_rust_bridge::for_generated::transform_result_dco;
+use flutter_rust_bridge::for_generated::{transform_result_dco, Lockable};
 use flutter_rust_bridge::{Handler, IntoIntoDart};
 
 // Section: boilerplate

frb_codegen/assets/integration_template/REPLACE_ME_RUST_CRATE_DIR/src/frb_generated.web.rs

@@ -5,9 +5,9 @@
 
 use super::*;
 use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
-use flutter_rust_bridge::for_generated::transform_result_dco;
 use flutter_rust_bridge::for_generated::wasm_bindgen;
 use flutter_rust_bridge::for_generated::wasm_bindgen::prelude::*;
+use flutter_rust_bridge::for_generated::{transform_result_dco, Lockable};
 use flutter_rust_bridge::{Handler, IntoIntoDart};
 
 // Section: boilerplate

frb_codegen/assets/integration_template/lib/src/rust/frb_generated.dart

@@ -6,6 +6,7 @@
 import 'api/simple.dart';
 import 'dart:async';
 import 'dart:convert';
+import 'frb_generated.dart';
 import 'frb_generated.io.dart' if (dart.library.html) 'frb_generated.web.dart';
 import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
 

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/method.rs

@@ -81,7 +81,7 @@ fn compute_class_name_for_querying_methods(ty: &MirType) -> NamespacedName {
         MirType::StructRef(ty) => ty.ident.0.clone(),
         MirType::TraitDef(ty) => ty.name.clone(),
         MirType::Delegate(MirTypeDelegate::ProxyVariant(ty)) => {
-            compute_class_name_for_querying_methods(&*ty.inner)
+            compute_class_name_for_querying_methods(&ty.inner)
         }
         MirType::RustAutoOpaqueImplicit(ty) => {
             compute_class_name_for_querying_methods(&MirType::RustOpaque(ty.inner.clone()))

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/delegate.rs

@@ -13,7 +13,6 @@ use crate::codegen::ir::mir::ty::MirType;
 use crate::library::codegen::generator::api_dart::spec_generator::base::*;
 use crate::library::codegen::generator::api_dart::spec_generator::info::ApiDartGeneratorInfoTrait;
 use crate::utils::basic_code::dart_header_code::DartHeaderCode;
-use crate::utils::namespace::NamespacedName;
 
 impl<'a> ApiDartGeneratorClassTrait for DelegateApiDartGenerator<'a> {
     fn generate_class(&self) -> Option<ApiDartGeneratedClass> {

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/class/ty/rust_opaque.rs

@@ -12,10 +12,7 @@ use crate::library::codegen::generator::api_dart::spec_generator::base::*;
 use crate::library::codegen::generator::api_dart::spec_generator::info::ApiDartGeneratorInfoTrait;
 use crate::library::codegen::ir::mir::ty::MirTypeTrait;
 use crate::utils::basic_code::dart_header_code::DartHeaderCode;
-use crate::utils::namespace::NamespacedName;
 use itertools::{concat, Itertools};
-use lazy_static::lazy_static;
-use regex::Regex;
 
 impl<'a> ApiDartGeneratorClassTrait for RustOpaqueApiDartGenerator<'a> {
     fn generate_class(&self) -> Option<ApiDartGeneratedClass> {

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/info.rs

@@ -88,13 +88,14 @@ impl<'a> ApiDartGeneratorInfoTrait for DelegateApiDartGenerator<'a> {
             MirTypeDelegate::BigPrimitive(_) => "BigInt".to_owned(),
             MirTypeDelegate::RustAutoOpaqueExplicit(mir) => {
                 ApiDartGenerator::new(mir.inner.clone(), self.context).dart_api_type()
-            } // MirTypeDelegate::DynTrait(mir) => mir.trait_def_name.name.clone(),
+            }
             MirTypeDelegate::ProxyVariant(mir) => {
                 ApiDartGenerator::new(mir.inner.clone(), self.context).dart_api_type()
             }
             MirTypeDelegate::ProxyEnum(mir) => {
                 ApiDartGenerator::new(mir.original.clone(), self.context).dart_api_type()
             }
+            MirTypeDelegate::DynTrait(mir) => mir.trait_def_name.name.clone(),
         }
     }
 

frb_codegen/src/library/codegen/generator/api_dart/spec_generator/misc.rs

@@ -101,10 +101,13 @@ fn generate_imports_from_ty(
                 current_file_namespace,
             );
             let path_b = (path_b_inner.parent()).with_context(|| {
+                // This will stop the whole generator and tell the users, so we do not care about testing it
+                // frb-coverage:ignore-start
                 format!(
                     "no parent for path_b_inner={path_b_inner:?} \
                     (current_file_namespace={current_file_namespace}, ty_namespace={ty_namespace} current_file_namespace={current_file_namespace:?} ty={ty:?})"
                 )
+                // frb-coverage:ignore-end
             });
 
             let path_diff = diff_paths(path_a, path_b?).context("cannot diff path")?;

frb_codegen/src/library/codegen/generator/codec/sse/encode_to_enum.rs

@@ -0,0 +1,32 @@
+use itertools::Itertools;
+
+pub(super) fn generate_encode_to_enum(enum_name: &str, variants: &[VariantInfo]) -> String {
+    let variants = (variants.iter())
+        .map(|variant| {
+            format!(
+                "if (self is {ty_name}) {{
+                    return {enum_name}.{enum_variant_name}(self{extra_code});
+                }}
+                ",
+                ty_name = variant.ty_name,
+                enum_variant_name = variant.enum_variant_name,
+                extra_code = variant.extra_code,
+            )
+        })
+        .join("");
+
+    format!(
+        "
+        (() {{
+            {variants}
+            throw Exception('not reachable');
+        }})()
+        "
+    )
+}
+
+pub(crate) struct VariantInfo {
+    pub enum_variant_name: String,
+    pub ty_name: String,
+    pub extra_code: String,
+}

frb_codegen/src/library/codegen/generator/codec/sse/mod.rs

@@ -1,3 +1,4 @@
+mod encode_to_enum;
 pub(crate) mod lang;
 pub(crate) mod misc;
 pub(crate) mod ty;

frb_codegen/src/library/codegen/generator/codec/sse/ty/delegate.rs

@@ -1,10 +1,11 @@
 use crate::codegen::generator::api_dart::spec_generator::base::ApiDartGenerator;
 use crate::codegen::generator::api_dart::spec_generator::class::proxy_variant;
+use crate::codegen::generator::codec::sse::encode_to_enum;
 use crate::codegen::generator::codec::sse::lang::*;
 use crate::codegen::generator::codec::sse::ty::*;
 use crate::codegen::ir::mir::ty::delegate::{
-    MirTypeDelegatePrimitiveEnum, MirTypeDelegateProxyEnum, MirTypeDelegateSet,
-    MirTypeDelegateStreamSink, MirTypeDelegateTime,
+    MirTypeDelegateDynTrait, MirTypeDelegatePrimitiveEnum, MirTypeDelegateProxyEnum,
+    MirTypeDelegateSet, MirTypeDelegateStreamSink, MirTypeDelegateTime,
 };
 use crate::library::codegen::generator::api_dart::spec_generator::info::ApiDartGeneratorInfoTrait;
 use convert_case::{Case, Casing};
@@ -46,7 +47,10 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> {
                 MirTypeDelegate::RustAutoOpaqueExplicit(_ir) => "self".to_owned(),
                 MirTypeDelegate::ProxyEnum(mir) => {
                     generate_proxy_enum_dart_encode(mir, self.context.as_api_dart_context())
-                } // MirTypeDelegate::DynTrait(_ir) => lang.throw_unimplemented(""),
+                }
+                MirTypeDelegate::DynTrait(mir) => {
+                    generate_dyn_trait_dart_encode(mir, self.context.as_api_dart_context())
+                }
             },
             Lang::RustLang(_) => match &self.mir {
                 MirTypeDelegate::Array(_) => {
@@ -85,18 +89,15 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> {
                     }
                 },
                 MirTypeDelegate::Uuid => "self.as_bytes().to_vec()".to_owned(),
-                MirTypeDelegate::StreamSink(_)
-                /*| MirTypeDelegate::DynTrait(_)*/ => {
-                    return Some(lang.throw_unimplemented(""))
-                }
+                MirTypeDelegate::StreamSink(_) => return Some(lang.throw_unimplemented("")),
                 MirTypeDelegate::BigPrimitive(_) => "self.to_string()".to_owned(),
                 MirTypeDelegate::RustAutoOpaqueExplicit(_ir) => {
                     "flutter_rust_bridge::for_generated::rust_auto_opaque_explicit_encode(self)"
                         .to_owned()
                 }
                 MirTypeDelegate::ProxyVariant(_)
                 | MirTypeDelegate::ProxyEnum(_)
-                => return None,
+                | MirTypeDelegate::DynTrait(_) => return None,
             },
         };
         Some(simple_delegate_encode(
@@ -155,7 +156,9 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> {
                     }
                     MirTypeDelegate::BigPrimitive(_) => "BigInt.parse(inner)".to_owned(),
                     MirTypeDelegate::RustAutoOpaqueExplicit(_ir) => "inner".to_owned(),
-                    // MirTypeDelegate::DynTrait(_) => return Some(lang.throw_unimplemented("")),
+                    MirTypeDelegate::DynTrait(_) => {
+                        return Some(format!("{};", lang.throw_unimplemented("")))
+                    }
                 }
             }
             Lang::RustLang(_) => match &self.mir {
@@ -197,8 +200,10 @@ impl<'a> CodecSseTyTrait for DelegateCodecSseTy<'a> {
                 MirTypeDelegate::RustAutoOpaqueExplicit(_ir) => {
                     "flutter_rust_bridge::for_generated::rust_auto_opaque_explicit_decode(inner)"
                         .to_owned()
-                } // MirTypeDelegate::DynTrait(_ir) => lang.throw_unimplemented(""),
-                MirTypeDelegate::ProxyVariant(_) | MirTypeDelegate::ProxyEnum(_) => return None,
+                }
+                MirTypeDelegate::ProxyVariant(_)
+                | MirTypeDelegate::ProxyEnum(_)
+                | MirTypeDelegate::DynTrait(_) => return None,
             },
         };
 
@@ -289,26 +294,32 @@ fn generate_proxy_enum_dart_encode(
     mir: &MirTypeDelegateProxyEnum,
     context: ApiDartGeneratorContext,
 ) -> String {
-    let enum_name = mir.proxy_enum_name();
+    let enum_name = mir.delegate_enum_name();
 
     let variants = (mir.variants.iter().enumerate())
-        .map(|(index, variant)| {
-            let variant_dart_extra_type = proxy_variant::compute_dart_extra_type(variant, context);
-            format!(
-                "if (self is {variant_dart_extra_type}) {{
-                    return {enum_name}.variant{index}(self._upstream);
-                }}
-                "
-            )
+        .map(|(index, variant)| encode_to_enum::VariantInfo {
+            enum_variant_name: format!("variant{index}"),
+            ty_name: proxy_variant::compute_dart_extra_type(variant, context),
+            extra_code: "._upstream".to_owned(),
         })
-        .join("");
+        .collect_vec();
 
-    format!(
-        "
-        (() {{
-            {variants}
-            throw Exception('not reachable');
-        }})()
-        "
-    )
+    encode_to_enum::generate_encode_to_enum(&enum_name, &variants)
+}
+
+fn generate_dyn_trait_dart_encode(
+    mir: &MirTypeDelegateDynTrait,
+    context: ApiDartGeneratorContext,
+) -> String {
+    let enum_name = mir.delegate_enum_name();
+
+    let variants = (mir.data().variants.iter().enumerate())
+        .map(|(index, variant)| encode_to_enum::VariantInfo {
+            enum_variant_name: format!("variant{index}"),
+            ty_name: ApiDartGenerator::new(variant.ty.clone(), context).dart_api_type(),
+            extra_code: "".to_owned(),
+        })
+        .collect_vec();
+
+    encode_to_enum::generate_encode_to_enum(&enum_name, &variants)
 }

frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/cst/encoder/ty/delegate.rs

@@ -115,7 +115,7 @@ impl<'a> WireDartCodecCstGeneratorEncoderTrait for DelegateWireDartCodecCstGener
             // ))),
             MirTypeDelegate::Backtrace
             | MirTypeDelegate::AnyhowException
-            /*| MirTypeDelegate::DynTrait(_)*/ => {
+            | MirTypeDelegate::DynTrait(_) => {
                 Acc::distribute(Some("throw UnimplementedError();".to_string()))
             }
             MirTypeDelegate::Map(_) => Acc::distribute(Some(format!(

frb_codegen/src/library/codegen/generator/wire/dart/spec_generator/codec/dco/decoder/ty/delegate.rs

@@ -81,7 +81,7 @@ impl<'a> WireDartCodecDcoGeneratorDecoderTrait for DelegateWireDartCodecDcoGener
                 "return Set.from(dco_decode_{}(raw));",
                 self.mir.get_delegate().safe_ident(),
             ),
-            MirTypeDelegate::StreamSink(_) /*| MirTypeDelegate::DynTrait(_)*/ => "throw UnimplementedError();".to_owned(),
+            MirTypeDelegate::StreamSink(_) | MirTypeDelegate::DynTrait(_) => "throw UnimplementedError();".to_owned(),
             MirTypeDelegate::BigPrimitive(_) => {
                 "return BigInt.parse(raw);".to_owned()
             }

frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/codec/cst/decoder/ty/delegate.rs

@@ -80,7 +80,7 @@ impl<'a> WireRustCodecCstGeneratorDecoderTrait for DelegateWireRustCodecCstGener
             //         "let multiple: Vec<u8> = self.cst_decode(); flutter_rust_bridge::for_generated::decode_uuids(multiple)".into(),
             //     ),
             // ),
-            MirTypeDelegate::Backtrace | MirTypeDelegate::AnyhowException /*| MirTypeDelegate::DynTrait(_)*/ => Acc::new(|target| match target {
+            MirTypeDelegate::Backtrace | MirTypeDelegate::AnyhowException | MirTypeDelegate::DynTrait(_) => Acc::new(|target| match target {
                 TargetOrCommon::Common => None,
                 TargetOrCommon::Io | TargetOrCommon::Web => Some("unimplemented!()".into()),
             }),
@@ -134,7 +134,7 @@ impl<'a> WireRustCodecCstGeneratorDecoderTrait for DelegateWireRustCodecCstGener
                 "self.unchecked_into::<flutter_rust_bridge::for_generated::js_sys::Uint8Array>().to_vec().into_boxed_slice().cst_decode()"
                     .into()
             }
-            MirTypeDelegate::Backtrace | MirTypeDelegate::AnyhowException /*| MirTypeDelegate::DynTrait(_)*/ => "unimplemented!()".into(),
+            MirTypeDelegate::Backtrace | MirTypeDelegate::AnyhowException | MirTypeDelegate::DynTrait(_) => "unimplemented!()".into(),
             MirTypeDelegate::Array(array) => generate_decode_array(array)
                 .into(),
             MirTypeDelegate::Map(mir) => generate_decode_map(mir).into(),

frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/function/lockable.rs

@@ -99,6 +99,8 @@
             Some(ty.ownership_mode)
         }
         MirType::Delegate(MirTypeDelegate::ProxyEnum(ty)) => compute_interest_field(&ty.original),
+        // temporarily only support Ref
+        MirType::Delegate(MirTypeDelegate::DynTrait(_)) => Some(OwnershipMode::Ref),
         _ => None,
     }
 }
@@ -107,3 +109,14 @@
     field: &'a MirFuncInput,
     ownership_mode: OwnershipMode,
 }
+
+pub(crate) fn generate_inner_func_arg_ownership(field: &MirFuncInput) -> String {
+    match &field.inner.ty {
+        MirType::RustAutoOpaqueImplicit(_) | MirType::Delegate(MirTypeDelegate::DynTrait(_)) => {
+            "".to_owned()
+        }
+        _ => (field.ownership_mode.map(|x| x.prefix()))
+            .unwrap_or_default()
+            .to_owned(),
+    }
+}

frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/function/mod.rs

@@ -12,7 +12,6 @@ use crate::codegen::generator::wire::rust::spec_generator::output_code::WireRust
 use crate::codegen::ir::mir::func::{MirFunc, MirFuncMode, MirFuncOwnerInfo};
 use crate::codegen::ir::mir::ty::primitive::MirTypePrimitive;
 use crate::codegen::ir::mir::ty::MirType;
-use crate::if_then_some;
 use crate::misc::consts::HANDLER_NAME;
 use convert_case::{Case, Casing};
 use itertools::Itertools;
@@ -70,22 +69,12 @@ pub(crate) fn generate_wire_func(
 }
 
 fn generate_inner_func_args(func: &MirFunc) -> Vec<String> {
-    let ans = func
-        .inputs
-        .iter()
+    (func.inputs.iter())
         .map(|field| {
-            let mut ans = format!("api_{}", field.inner.name.rust_style());
-            let ownership_mode =
-                if_then_some!(let MirType::RustAutoOpaqueImplicit(o) = &field.inner.ty, o.ownership_mode)
-                    .or(field.ownership_mode);
-            if let Some(ownership_mode) = ownership_mode {
-                ans = format!("{}{ans}", ownership_mode.prefix())
-            }
-            ans
+            let ownership = lockable::generate_inner_func_arg_ownership(field);
+            format!("{ownership}api_{}", field.inner.name.rust_style())
         })
-        .collect_vec();
-
-    ans
+        .collect_vec()
 }
 
 fn generate_wrap_info_obj(func: &MirFunc) -> String {

frb_codegen/src/library/codegen/generator/wire/rust/spec_generator/misc/ty/delegate.rs

@@ -16,10 +16,10 @@ impl<'a> WireRustGeneratorMiscTrait for DelegateWireRustGenerator<'a> {
     }
 
     fn generate_wire_func_call_decode_type(&self) -> Option<String> {
-        if let MirTypeDelegate::ProxyEnum(mir) = &self.mir {
-            Some(mir.get_delegate().rust_api_type())
-        } else {
-            None
+        match &self.mir {
+            MirTypeDelegate::ProxyEnum(mir) => Some(mir.get_delegate().rust_api_type()),
+            MirTypeDelegate::DynTrait(mir) => Some(mir.get_delegate().rust_api_type()),
+            _ => None,
         }
     }
 }

frb_codegen/src/library/codegen/ir/early_generator/mod.rs

@@ -1,2 +1,3 @@
 pub(crate) mod pack;
 pub(crate) mod proxied_type;
+pub(crate) mod trait_def_info;

frb_codegen/src/library/codegen/ir/early_generator/pack.rs

@@ -1,9 +1,10 @@
 use crate::codegen::ir::early_generator::proxied_type::IrEarlyGeneratorProxiedType;
+use crate::codegen::ir::early_generator::trait_def_info::IrEarlyGeneratorTraitDefInfo;
 use crate::codegen::ir::hir::flat::pack::HirFlatPack;
-use crate::codegen::ir::mir::ty::MirType;
 
 #[derive(Debug, Clone, Default, serde::Serialize)]
 pub(crate) struct IrEarlyGeneratorPack {
     pub hir_flat_pack: HirFlatPack,
     pub proxied_types: Vec<IrEarlyGeneratorProxiedType>,
+    pub trait_def_infos: Vec<IrEarlyGeneratorTraitDefInfo>,
 }

frb_codegen/src/library/codegen/ir/early_generator/proxied_type.rs

@@ -4,7 +4,7 @@ use crate::utils::namespace::Namespace;
 
 #[derive(Debug, Clone, serde::Serialize, PartialEq, Eq, Hash)]
 pub(crate) struct IrEarlyGeneratorProxiedType {
-    pub proxy_enum_namespace: Namespace,
     pub original_ty: MirType,
+    pub proxy_enum_namespace: Namespace,
     pub variants: Vec<MirTypeDelegateProxyVariant>,
 }

frb_codegen/src/library/codegen/ir/early_generator/trait_def_info.rs

@@ -0,0 +1,9 @@
+use crate::codegen::ir::mir::ty::delegate::MirTypeDelegateDynTraitVariant;
+use crate::utils::namespace::{Namespace, NamespacedName};
+
+#[derive(Debug, Clone, serde::Serialize, PartialEq, Eq, Hash)]
+pub(crate) struct IrEarlyGeneratorTraitDefInfo {
+    pub trait_def_name: NamespacedName,
+    pub delegate_namespace: Namespace,
+    pub variants: Vec<MirTypeDelegateDynTraitVariant>,
+}