Make generated Dart opaque class abstract to improve testability

frb_codegen/src/library/codegen/generator/api_dart/mod.rs

@@ -12,6 +12,7 @@ use anyhow::Result;
 
 pub(crate) struct GeneratorApiDartOutput {
     pub output_texts: PathTexts,
+    pub output_extra_impl_text: String,
     pub needs_freezed: bool,
 }
 
@@ -33,6 +34,7 @@ pub(crate) fn generate(
 
     Ok(GeneratorApiDartOutput {
         output_texts: text.output_texts,
+        output_extra_impl_text: text.output_extra_impl_text,
         needs_freezed: spec.namespaced_items.values().any(|x| x.needs_freezed),
     })
 }

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

@@ -13,13 +13,21 @@
 use convert_case::{Case, Casing};
 use itertools::Itertools;
 
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub(crate) enum GenerateApiMethodMode {
+    SeparatedDecl,
+    SeparatedImpl,
+    Combined,
+}
+
 pub(crate) fn generate_api_methods(
     generalized_class_name: &NamespacedName,
     context: ApiDartGeneratorContext,
+    mode: GenerateApiMethodMode,
 ) -> Vec<String> {
     get_methods_of_enum_or_struct(generalized_class_name, &context.mir_pack.funcs)
         .iter()
-        .map(|func| generate_api_method(func, context))
+        .filter_map(|func| generate_api_method(func, context, mode))
         .collect_vec()
 }
 
@@ -52,18 +60,30 @@
         .collect_vec()
 }
 
-fn generate_api_method(func: &MirFunc, context: ApiDartGeneratorContext) -> String {
+fn generate_api_method(
+    func: &MirFunc,
+    context: ApiDartGeneratorContext,
+    mode: GenerateApiMethodMode,
+) -> Option<String> {
     let api_dart_func = api_dart::spec_generator::function::generate(func, context).unwrap();
 
     let method_info =
         if_then_some!(let MirFuncOwnerInfo::Method(info) = &func.owner , info).unwrap();
+
+    if method_info.mode == MirFuncOwnerInfoMethodMode::Static
+        && mode == GenerateApiMethodMode::SeparatedImpl
+    {
+        return None;
+    }
+
     let default_constructor_mode = func.default_constructor_mode();
 
     let skip_names = compute_skip_names(method_info);
     let params = (api_dart_func.func_params.iter())
         .filter(|param| !skip_names.contains(&&param.name_str[..]))
         .cloned()
         .collect_vec();
+    let method_name = generate_method_name(method_info, default_constructor_mode);
 
     let comments = generate_comments(func, default_constructor_mode);
     let signature = generate_signature(
@@ -72,10 +92,15 @@
         &params,
         default_constructor_mode,
         &api_dart_func,
+        &method_name,
+        mode,
     );
-    let implementation = generate_implementation(func, context, method_info, &params);
 
-    format!("{comments}{signature}=>{implementation};\n\n")
+    let maybe_implementation =
+        generate_maybe_implementation(func, context, method_info, &params, mode);
+    let maybe_implementation = (maybe_implementation.map(|x| format!("=>{x}"))).unwrap_or_default();
+
+    Some(format!("{comments}{signature}{maybe_implementation};\n\n"))
 }
 
 fn compute_skip_names(method_info: &MirFuncOwnerInfoMethod) -> Vec<&'static str> {
@@ -107,19 +132,12 @@
     func_params: &[ApiDartGeneratedFunctionParam],
     default_constructor_mode: Option<MirFuncDefaultConstructorMode>,
     api_dart_func: &ApiDartGeneratedFunction,
+    method_name: &str,
+    mode: GenerateApiMethodMode,
 ) -> String {
     let is_static_method = method_info.mode == MirFuncOwnerInfoMethodMode::Static;
     let maybe_static = if is_static_method { "static" } else { "" };
     let return_type = &api_dart_func.func_return_type;
-    let method_name = if default_constructor_mode.is_some() {
-        "newInstance".to_owned()
-    } else {
-        (method_info
-            .actual_method_dart_name
-            .as_ref()
-            .unwrap_or(&method_info.actual_method_name))
-        .to_case(Case::Camel)
-    };
     let (func_params, maybe_accessor) = match func.accessor {
         Some(MirFuncAccessorMode::Getter) => ("".to_owned(), "get"),
         Some(MirFuncAccessorMode::Setter) => (
@@ -139,13 +157,51 @@
     };
 
     if default_constructor_mode == Some(MirFuncDefaultConstructorMode::DartConstructor) {
-        return format!("factory {return_type}{func_params}");
+        let owner_ty_name = method_info.owner_ty_name().unwrap().name;
+        let class_postfix = if mode == GenerateApiMethodMode::SeparatedImpl {
+            "Impl"
+        } else {
+            ""
+        };
+        return format!("factory {owner_ty_name}{class_postfix}{func_params}");
     }
 
     format!("{maybe_static} {return_type} {maybe_accessor} {method_name}{func_params}")
 }
 
-fn generate_implementation(
+fn generate_method_name(
+    method_info: &MirFuncOwnerInfoMethod,
+    default_constructor_mode: Option<MirFuncDefaultConstructorMode>,
+) -> String {
+    if default_constructor_mode.is_some() {
+        "newInstance".to_owned()
+    } else {
+        (method_info
+            .actual_method_dart_name
+            .as_ref()
+            .unwrap_or(&method_info.actual_method_name))
+        .to_case(Case::Camel)
+    }
+}
+
+fn generate_maybe_implementation(
+    func: &MirFunc,
+    context: ApiDartGeneratorContext,
+    method_info: &MirFuncOwnerInfoMethod,
+    params: &[ApiDartGeneratedFunctionParam],
+    mode: GenerateApiMethodMode,
+) -> Option<String> {
+    match (mode, method_info.mode.to_owned()) {
+        (GenerateApiMethodMode::Combined, _)
+        | (GenerateApiMethodMode::SeparatedDecl, MirFuncOwnerInfoMethodMode::Static)
+        | (GenerateApiMethodMode::SeparatedImpl, MirFuncOwnerInfoMethodMode::Instance) => Some(
+            generate_implementation_call_impl(func, context, method_info, params),
+        ),
+        _ => None,
+    }
+}
+
+fn generate_implementation_call_impl(
     func: &MirFunc,
     context: ApiDartGeneratorContext,
     method_info: &MirFuncOwnerInfoMethod,

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

@@ -1,4 +1,6 @@
-use crate::codegen::generator::api_dart::spec_generator::class::method::generate_api_methods;
+use crate::codegen::generator::api_dart::spec_generator::class::method::{
+    generate_api_methods, GenerateApiMethodMode,
+};
 use crate::codegen::generator::api_dart::spec_generator::class::misc::generate_class_extra_body;
 use crate::codegen::generator::api_dart::spec_generator::class::ty::ApiDartGeneratorClassTrait;
 use crate::codegen::generator::api_dart::spec_generator::class::ApiDartGeneratedClass;
@@ -9,7 +11,9 @@ impl<'a> ApiDartGeneratorClassTrait for EnumRefApiDartGenerator<'a> {
     fn generate_class(&self) -> Option<ApiDartGeneratedClass> {
         let src = self.mir.get(self.context.mir_pack);
 
-        let methods_str = generate_api_methods(&src.name, self.context).join("\n");
+        let methods_str =
+            generate_api_methods(&src.name, self.context, GenerateApiMethodMode::Combined)
+                .join("\n");
         let extra_body =
             generate_class_extra_body(self.mir_type(), &self.context.mir_pack.dart_code_of_type);
 

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

@@ -16,6 +16,11 @@ pub(crate) trait ApiDartGeneratorClassTrait {
     fn generate_class(&self) -> Option<ApiDartGeneratedClass> {
         None
     }
+
+    /// The code will not be put in dart api files, but instead be in `frb_generated.dart`
+    fn generate_extra_impl_code(&self) -> Option<String> {
+        None
+    }
 }
 
 // the following have empty implementation

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

@@ -1,4 +1,6 @@
-use crate::codegen::generator::api_dart::spec_generator::class::method::generate_api_methods;
+use crate::codegen::generator::api_dart::spec_generator::class::method::{
+    generate_api_methods, GenerateApiMethodMode,
+};
 use crate::codegen::generator::api_dart::spec_generator::class::misc::generate_class_extra_body;
 use crate::codegen::generator::api_dart::spec_generator::class::ty::ApiDartGeneratorClassTrait;
 use crate::codegen::generator::api_dart::spec_generator::class::ApiDartGeneratedClass;
@@ -12,20 +14,13 @@ use regex::Regex;
 
 impl<'a> ApiDartGeneratorClassTrait for RustOpaqueApiDartGenerator<'a> {
     fn generate_class(&self) -> Option<ApiDartGeneratedClass> {
-        let dart_entrypoint_class_name = &self.context.config.dart_entrypoint_class_name;
-        let dart_api_instance = format!("{dart_entrypoint_class_name}.instance.api");
+        let Info {
+            dart_api_type,
+            methods,
+        } = self.compute_info(GenerateApiMethodMode::SeparatedDecl);
 
         let rust_api_type = self.mir.rust_api_type();
-        let dart_api_type = ApiDartGenerator::new(self.mir.clone(), self.context).dart_api_type();
 
-        let methods = generate_api_methods(
-            &NamespacedName::new(
-                self.mir.namespace.clone(),
-                compute_api_method_query_name(&self.mir, self.context),
-            ),
-            self.context,
-        )
-        .join("\n");
         let extra_body =
             generate_class_extra_body(self.mir_type(), &self.context.mir_pack.dart_code_of_type);
 
@@ -34,14 +29,43 @@ impl<'a> ApiDartGeneratorClassTrait for RustOpaqueApiDartGenerator<'a> {
             class_name: dart_api_type.clone(),
             code: format!(
                 "
-            // Rust type: {rust_api_type}
-            @sealed class {dart_api_type} extends RustOpaque {{
+                // Rust type: {rust_api_type}
+                abstract class {dart_api_type} {{
+                    {methods}
+
+                    void dispose();
+
+                    bool get isDisposed;
+
+                    {extra_body}
+                }}
+                "
+            ),
+            needs_freezed: false,
+            header: Default::default(),
+        })
+    }
+
+    fn generate_extra_impl_code(&self) -> Option<String> {
+        let Info {
+            dart_api_type,
+            methods,
+        } = self.compute_info(GenerateApiMethodMode::SeparatedImpl);
+
+        let dart_api_type_impl = format!("{dart_api_type}Impl");
+
+        let dart_entrypoint_class_name = &self.context.config.dart_entrypoint_class_name;
+        let dart_api_instance = format!("{dart_entrypoint_class_name}.instance.api");
+
+        Some(format!(
+            "
+            @sealed class {dart_api_type_impl} extends RustOpaque implements {dart_api_type} {{
                 // Not to be used by end users
-                {dart_api_type}.frbInternalDcoDecode(List<dynamic> wire):
+                {dart_api_type_impl}.frbInternalDcoDecode(List<dynamic> wire):
                     super.frbInternalDcoDecode(wire, _kStaticData);
 
                 // Not to be used by end users
-                {dart_api_type}.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative):
+                {dart_api_type_impl}.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative):
                     super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);
 
                 static final _kStaticData = RustArcStaticData(
@@ -51,15 +75,37 @@ impl<'a> ApiDartGeneratorClassTrait for RustOpaqueApiDartGenerator<'a> {
                 );
 
                 {methods}
-                {extra_body}
             }}"
+        ))
+    }
+}
+
+impl RustOpaqueApiDartGenerator<'_> {
+    fn compute_info(&self, mode: GenerateApiMethodMode) -> Info {
+        let dart_api_type = ApiDartGenerator::new(self.mir.clone(), self.context).dart_api_type();
+
+        let methods = generate_api_methods(
+            &NamespacedName::new(
+                self.mir.namespace.clone(),
+                compute_api_method_query_name(&self.mir, self.context),
             ),
-            needs_freezed: false,
-            header: Default::default(),
-        })
+            self.context,
+            mode,
+        )
+        .join("\n");
+
+        Info {
+            dart_api_type,
+            methods,
+        }
     }
 }
 
+struct Info {
+    dart_api_type: String,
+    methods: String,
+}
+
 fn compute_api_method_query_name(
     mir: &MirTypeRustOpaque,
     _context: ApiDartGeneratorContext,

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

@@ -1,5 +1,5 @@
 use crate::codegen::generator::api_dart::spec_generator::class::method::{
-    dart_constructor_postfix, generate_api_methods,
+    dart_constructor_postfix, generate_api_methods, GenerateApiMethodMode,
 };
 use crate::codegen::generator::api_dart::spec_generator::class::misc::generate_class_extra_body;
 use crate::codegen::generator::api_dart::spec_generator::class::ty::ApiDartGeneratorClassTrait;
@@ -15,7 +15,8 @@ impl<'a> ApiDartGeneratorClassTrait for StructRefApiDartGenerator<'a> {
         let comments = generate_dart_comments(&src.comments);
         let metadata = generate_dart_metadata(&src.dart_metadata);
 
-        let methods = generate_api_methods(&src.name, self.context);
+        let methods =
+            generate_api_methods(&src.name, self.context, GenerateApiMethodMode::Combined);
         let extra_body =
             generate_class_extra_body(self.mir_type(), &self.context.mir_pack.dart_code_of_type);
 

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

@@ -40,6 +40,7 @@ pub(crate) struct ApiDartOutputSpec {
 pub(crate) struct ApiDartOutputSpecItem {
     pub funcs: Vec<ApiDartGeneratedFunction>,
     pub classes: Vec<ApiDartGeneratedClass>,
+    pub extra_impl_code: Vec<String>,
     pub imports: DartBasicHeaderCode,
     pub preamble: String,
     pub skips: Vec<MirSkip>,
@@ -116,20 +117,30 @@ fn generate_item(
 
     let classes = namespaced_types
         .map(|classes| {
-            classes
-                .iter()
+            (classes.iter())
                 .filter_map(|&ty| ApiDartGenerator::new(ty.clone(), context).generate_class())
                 .collect_vec()
         })
         .unwrap_or_default();
 
+    let extra_impl_code = namespaced_types
+        .map(|classes| {
+            (classes.iter())
+                .filter_map(|&ty| {
+                    ApiDartGenerator::new(ty.clone(), context).generate_extra_impl_code()
+                })
+                .collect_vec()
+        })
+        .unwrap_or_default();
+
     sanity_check_class_name_duplicates(&classes)?;
 
     let needs_freezed = classes.iter().any(|class| class.needs_freezed);
 
     Ok(ApiDartOutputSpecItem {
         funcs,
         classes,
+        extra_impl_code,
         imports,
         preamble: context.config.dart_preamble.clone(),
         skips: compute_skips(context.mir_pack, namespace),