Support for Result<MyType, MyError> with exception throwing on Dart

.github/workflows/ci.yaml

@@ -33,7 +33,11 @@ jobs:
           python-version: "3.x"
 
       - name: Install valgrind and llvm
-        run: sudo apt update && sudo apt install -y valgrind libclang-dev
+        run: |
+          sudo apt update && sudo apt install -y libclang-dev libc6-dbg \
+          && wget -O valgrind.tar.bz2 https://sourceware.org/pub/valgrind/valgrind-3.19.0.tar.bz2 \
+          && mkdir valgrind && tar -xvjf valgrind.tar.bz2 -C valgrind --strip-components=1 \
+          && cd valgrind && ./configure && make && sudo make install
 
       - uses: dart-lang/setup-dart@v1
 

book/src/SUMMARY.md

@@ -15,6 +15,7 @@
     - [External types](feature/lang_external.md)
     - [Option](feature/lang_option.md)
     - [Methods](feature/lang_methods.md)
+    - [Result](feature/lang_result.md)
     - [Return types](feature/lang_return_types.md)
   - [Zero copy](feature/zero_copy.md)
   - [Stream / Iterator](feature/stream.md)

book/src/feature/lang_result.md

@@ -0,0 +1,51 @@
+# Result
+
+There is support for Rust's `std::Result`, where you can return either a value or an error.
+
+## `anyhow`
+
+You can use `anyhow::Result` as a return value, and backtraces will be captured automatically.
+
+## Custom errors
+
+Errors with custom fields are also supported, and you can even pass a backtrace.
+
+### Example 1: Without backtrace
+
+```rust,noplayground
+
+pub enum CustomError {
+    Error0(String),
+    Error1(u32),
+}
+
+pub fn return_err_custom_error() -> Result<u32, CustomError> {
+    Err(CustomError::Error1(3))
+}
+```
+
+Becomes something that can be used like this:
+
+```Dart
+try {
+      final r = await api.returnErrCustomError();
+      print("received $r");
+    } catch (e) {
+      print('dart catch e: $e');
+      expect(e, isA<CustomError>());
+    }
+}
+```
+
+### Example 2: With backtrace
+
+Errors with custom fields are also supported, and you can even pass a backtrace:
+
+```rust
+pub enum CustomStructError {
+    Error0 { e: String, backtrace: Backtrace },
+    Error1 { e: u32, backtrace: Backtrace },
+}
+```
+
+As for how to fill it in or use it, you can refer to `thiserror` crate for some hints.

frb_codegen/src/config.rs

@@ -16,7 +16,7 @@ use crate::ir::IrFile;
 use crate::parser;
 use crate::utils::BlockIndex;
 
-#[derive(StructOpt, Debug, PartialEq, Deserialize, Default)]
+#[derive(StructOpt, Debug, PartialEq, Eq, Deserialize, Default)]
 #[structopt(setting(AppSettings::DeriveDisplayOrder))]
 pub struct RawOpts {
     /// Path of input Rust code

frb_codegen/src/generator/dart/mod.rs

@@ -407,7 +407,11 @@ fn generate_api_func(func: &IrFunc, ir_file: &IrFile) -> GeneratedApiFunc {
     };
     let parse_sucess_data = if (f.is_static_method()
         && f.struct_name().unwrap() == {
-            if let IrType::StructRef(IrTypeStructRef { name, freezed: _ }) = &func.output {
+            if let IrType::StructRef(IrTypeStructRef {
+                name,
+                ..
+            }) = &func.output
+            {
                 name.clone()
             } else {
                 "".to_string()
@@ -424,6 +428,12 @@ fn generate_api_func(func: &IrFunc, ir_file: &IrFile) -> GeneratedApiFunc {
         format!("_wire2api_{}", func.output.safe_ident())
     };
 
+    let parse_error_data = if let Some(error_output) = &func.error_output {
+        format!("_wire2api_{},", error_output.safe_ident())
+    } else {
+        "null,".to_string()
+    };
+
     let implementation = match func.mode {
         IrFuncMode::Sync => format!(
             "{} => {}(FlutterRustBridgeSyncTask(
@@ -440,13 +450,15 @@ fn generate_api_func(func: &IrFunc, ir_file: &IrFile) -> GeneratedApiFunc {
             "{} => {}(FlutterRustBridgeTask(
             callFfi: (port_) => inner.{}({}),
             parseSuccessData: {},
+            parseErrorData: {}
             {}
         ));",
             partial,
             execute_func_name,
             func.wire_func_name(),
             wire_param_list.join(", "),
             parse_sucess_data,
+            parse_error_data,
             task_common_args,
         ),
     };
@@ -521,7 +533,7 @@ fn generate_api_fill_to_wire_func(ty: &IrType, ir_file: &IrFile) -> String {
 }
 
 fn generate_wire2api_func(ty: &IrType, ir_file: &IrFile, dart_api_class_name: &str) -> String {
-    let extra_argument = if matches!(ty, StructRef(IrTypeStructRef { name, freezed: _ }) if MethodNamingUtil::has_methods(name, ir_file))
+    let extra_argument = if matches!(ty, StructRef(IrTypeStructRef { name, ..}) if MethodNamingUtil::has_methods(name, ir_file))
     {
         format!("{} bridge,", dart_api_class_name)
     } else {

frb_codegen/src/generator/dart/ty_delegate.rs

@@ -30,12 +30,15 @@ impl TypeDartGeneratorTrait for TypeDelegateGenerator<'_> {
             IrTypeDelegate::PrimitiveEnum { ref repr, .. } => {
                 format!("return _api2wire_{}(raw.index);", repr.safe_ident())
             }
+            IrTypeDelegate::Backtrace => unimplemented!(),
+            IrTypeDelegate::Anyhow => unimplemented!(),
         })
     }
 
     fn wire2api_body(&self) -> String {
         match &self.ir {
             IrTypeDelegate::String
+            | IrTypeDelegate::Backtrace
             | IrTypeDelegate::SyncReturnVecU8
             | IrTypeDelegate::ZeroCopyBufferVecPrimitive(_) => {
                 gen_wire2api_simple_type_cast(&self.ir.dart_api_type())
@@ -46,6 +49,7 @@ impl TypeDartGeneratorTrait for TypeDelegateGenerator<'_> {
             IrTypeDelegate::PrimitiveEnum { ir, .. } => {
                 format!("return {}.values[raw];", ir.dart_api_type())
             }
+            IrTypeDelegate::Anyhow => "return FrbAnyhowException(raw as String);".to_string(),
         }
     }
 

frb_codegen/src/generator/dart/ty_enum.rs

@@ -2,6 +2,7 @@ use crate::generator::dart::dart_comments;
 use crate::generator::dart::ty::*;
 use crate::ir::*;
 use crate::type_dart_generator_struct;
+use crate::utils::dart_maybe_implements_exception;
 use crate::utils::BlockIndex;
 
 type_dart_generator_struct!(TypeEnumRefGenerator, IrTypeEnumRef);
@@ -107,6 +108,11 @@ impl TypeDartGeneratorTrait for TypeEnumRefGenerator<'_> {
                 .variants()
                 .iter()
                 .map(|variant| {
+                    let has_backtrace = matches!(&variant.kind, IrVariantKind::Struct(IrStruct {
+                        is_fields_named: true,
+                        fields,
+                        ..
+                    }) if fields.iter().any(|field| field.name.raw =="backtrace"));
                     let args = match &variant.kind {
                         IrVariantKind::Value => "".to_owned(),
                         IrVariantKind::Struct(IrStruct {
@@ -152,8 +158,14 @@ impl TypeDartGeneratorTrait for TypeEnumRefGenerator<'_> {
                             format!("{{ {} }}", fields.join(""))
                         }
                     };
+                    let implements_exception = if self.ir.is_exception && has_backtrace {
+                        "@Implements<FrbBacktracedException>()"
+                    } else {
+                        ""
+                    };
                     format!(
-                        "{}const factory {}.{}({}) = {};",
+                        "{} {}const factory {}.{}({}) = {};",
+                        implements_exception,
                         dart_comments(&variant.comments),
                         self.ir.name,
                         variant.name.dart_style(),
@@ -164,10 +176,11 @@ impl TypeDartGeneratorTrait for TypeEnumRefGenerator<'_> {
                 .collect::<Vec<_>>();
             format!(
                 "@freezed
-                class {0} with _${0} {{
-                    {1}
+                class {0} with _${0} {1} {{
+                    {2}
                 }}",
                 self.ir.name,
+                dart_maybe_implements_exception(self.ir.is_exception),
                 variants.join("\n")
             )
         } else {

frb_codegen/src/generator/dart/ty_struct.rs

@@ -3,7 +3,7 @@ use crate::generator::dart::{dart_comments, dart_metadata, GeneratedApiMethod};
 use crate::ir::*;
 use crate::method_utils::FunctionName;
 use crate::type_dart_generator_struct;
-use crate::utils::BlockIndex;
+use crate::utils::{dart_maybe_implements_exception, BlockIndex};
 use convert_case::{Case, Casing};
 
 type_dart_generator_struct!(TypeStructRefGenerator, IrTypeStructRef);
@@ -57,14 +57,13 @@ impl TypeDartGeneratorTrait for TypeStructRefGenerator<'_> {
             inner.insert(0, "bridge: bridge,".to_string());
         }
         let inner = inner.join("\n");
-
+        let cast = "final arr = raw as List<dynamic>;".to_string();
+        let safe_check = format!("if (arr.length != {}) throw Exception('unexpected arr length: expect {} but see ${{arr.length}}');", s.fields.len(), s.fields.len());
         format!(
-            "final arr = raw as List<dynamic>;
-                if (arr.length != {}) throw Exception('unexpected arr length: expect {} but see ${{arr.length}}');
+            "{}
+                {}
                 return {}({});",
-            s.fields.len(),
-            s.fields.len(),
-            s.name, inner,
+            cast, safe_check, s.name, inner,
         )
     }
 
@@ -118,20 +117,22 @@ impl TypeDartGeneratorTrait for TypeStructRefGenerator<'_> {
                     )
                 })
                 .collect::<Vec<_>>();
+
             if has_methods {
                 constructor_params.insert(0, extra_argument);
             }
             let constructor_params = constructor_params.join("");
 
             format!(
-                "{}{}class {} with _${} {{
+                "{}{}class {} with _${} {} {{
                 const factory {}({{{}}}) = _{};
                 {}
             }}",
                 comments,
                 metadata,
                 self.ir.name,
                 self.ir.name,
+                dart_maybe_implements_exception(self.ir.is_exception),
                 self.ir.name,
                 constructor_params,
                 self.ir.name,
@@ -156,7 +157,6 @@ impl TypeDartGeneratorTrait for TypeStructRefGenerator<'_> {
                 field_declarations.insert(0, field_bridge);
             }
             let field_declarations = field_declarations.join("\n");
-
             let mut constructor_params = src
                 .fields
                 .iter()
@@ -175,7 +175,7 @@ impl TypeDartGeneratorTrait for TypeStructRefGenerator<'_> {
             let constructor_params = constructor_params.join("");
 
             format!(
-                "{}{}class {} {{
+                "{}{}class {} {} {{
                 {}
 
                 {}({{{}}});
@@ -185,6 +185,7 @@ impl TypeDartGeneratorTrait for TypeStructRefGenerator<'_> {
                 comments,
                 metadata,
                 self.ir.name,
+                dart_maybe_implements_exception(self.ir.is_exception),
                 field_declarations,
                 self.ir.name,
                 constructor_params,

frb_codegen/src/generator/rust/mod.rs

@@ -309,7 +309,7 @@ impl Generator {
         let code_call_inner_func_result = if func.fallible {
             code_call_inner_func
         } else {
-            format!("Ok({})", code_call_inner_func)
+            format!("Result::<_,()>::Ok({})", code_call_inner_func)
         };
 
         let (handler_func_name, return_type, code_closure) = match func.mode {

frb_codegen/src/generator/rust/ty_delegate.rs

@@ -50,6 +50,7 @@ impl TypeRustGeneratorTrait for TypeDelegateGenerator<'_> {
                     variants, enu.name
                 )
             }
+            IrTypeDelegate::Backtrace | IrTypeDelegate::Anyhow => "self.wire2api()".to_owned(),
         })
     }
 

frb_codegen/src/ir/file.rs

@@ -30,6 +30,9 @@ impl IrFile {
             }
             if include_func_output {
                 func.output.visit_types(f, self);
+                if let Some(error_output) = &func.error_output {
+                    error_output.visit_types(f, self);
+                }
             }
         }
     }

frb_codegen/src/ir/func.rs

@@ -5,6 +5,7 @@ pub struct IrFunc {
     pub name: String,
     pub inputs: Vec<IrField>,
     pub output: IrType,
+    pub error_output: Option<IrType>,
     pub fallible: bool,
     pub mode: IrFuncMode,
     pub comments: Vec<IrComment>,
@@ -19,7 +20,7 @@ impl IrFunc {
 /// Represents a function's output type
 #[derive(Debug, Clone)]
 pub enum IrFuncOutput {
-    ResultType(IrType),
+    ResultType { ok: IrType, error: Option<IrType> },
     Type(IrType),
 }
 
@@ -30,7 +31,7 @@ pub enum IrFuncArg {
     Type(IrType),
 }
 
-#[derive(Debug, Clone, PartialOrd, PartialEq)]
+#[derive(Debug, Clone, PartialOrd, PartialEq, Eq)]
 pub enum IrFuncMode {
     Normal,
     Sync,

frb_codegen/src/ir/ty.rs

@@ -94,7 +94,7 @@ pub fn optional_boundary_index(types: &[&IrType]) -> Option<usize> {
         .enumerate()
         .find(|ty| matches!(ty.1, Optional(_)))
         .and_then(|(idx, _)| {
-            (&types[idx..])
+            (types[idx..])
                 .iter()
                 .all(|ty| matches!(ty, Optional(_)))
                 .then(|| idx)

frb_codegen/src/ir/ty_delegate.rs

@@ -12,6 +12,8 @@ pub enum IrTypeDelegate {
         /// Allows for `#[repr]`'s other than [i32]
         repr: IrTypePrimitive,
     },
+    Backtrace,
+    Anyhow,
 }
 
 impl IrTypeDelegate {
@@ -30,6 +32,8 @@ impl IrTypeDelegate {
             }
             IrTypeDelegate::StringList => IrType::Delegate(IrTypeDelegate::String),
             IrTypeDelegate::PrimitiveEnum { repr, .. } => IrType::Primitive(repr.clone()),
+            IrTypeDelegate::Backtrace => IrType::Delegate(IrTypeDelegate::String),
+            IrTypeDelegate::Anyhow => IrType::Delegate(IrTypeDelegate::String),
         }
     }
 }
@@ -48,6 +52,8 @@ impl IrTypeTrait for IrTypeDelegate {
                 "ZeroCopyBuffer_".to_owned() + &self.get_delegate().dart_api_type()
             }
             IrTypeDelegate::PrimitiveEnum { ir, .. } => ir.safe_ident(),
+            IrTypeDelegate::Backtrace => "String".to_owned(),
+            IrTypeDelegate::Anyhow => "FrbAnyhowException".to_owned(),
         }
     }
 
@@ -59,6 +65,8 @@ impl IrTypeTrait for IrTypeDelegate {
                 self.get_delegate().dart_api_type()
             }
             IrTypeDelegate::PrimitiveEnum { ir, .. } => ir.dart_api_type(),
+            IrTypeDelegate::Backtrace => "String".to_string(),
+            IrTypeDelegate::Anyhow => "FrbAnyhowException".to_string(),
         }
     }
 
@@ -78,6 +86,8 @@ impl IrTypeTrait for IrTypeDelegate {
                 format!("ZeroCopyBuffer<{}>", self.get_delegate().rust_api_type())
             }
             IrTypeDelegate::PrimitiveEnum { ir, .. } => ir.rust_api_type(),
+            IrTypeDelegate::Backtrace => "String".to_owned(),
+            IrTypeDelegate::Anyhow => "String".to_owned(),
         }
     }