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

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "allo-isolate"]
+	path = allo-isolate
+	url = https://github.com/sunshine-protocol/allo-isolate

book/src/feature/result.md

@@ -0,0 +1,31 @@
+# Result
+
+There is support for Rust's `std::Result`, where you can return either a value or an error.
+
+## Example
+
+```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>());
+    }
+}
+```

frb_codegen/src/generator/dart/mod.rs

@@ -410,6 +410,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!("parseErrorData: _wire2api_{},", error_output.safe_ident())
+    } else {
+        "parseErrorData: null,".to_string()
+    };
+
     let implementation = match func.mode {
         IrFuncMode::Sync => format!(
             "{} => {}(FlutterRustBridgeSyncTask(
@@ -427,12 +433,14 @@ fn generate_api_func(func: &IrFunc, ir_file: &IrFile) -> GeneratedApiFunc {
             callFfi: (port_) => inner.{}({}),
             parseSuccessData: {},
             {}
+            {}
         ));",
             partial,
             execute_func_name,
             func.wire_func_name(),
             wire_param_list.join(", "),
             parse_sucess_data,
+            parse_error_data,
             task_common_args,
         ),
     };

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/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(IrType, Option<IrType>),
     Type(IrType),
 }
 

frb_codegen/src/parser/mod.rs

@@ -63,12 +63,24 @@ impl<'a> Parser<'a> {
         let inner = ty::SupportedInnerType::try_from_syn_type(ty)?;
 
         match inner {
-            ty::SupportedInnerType::Path(ty::SupportedPathType {
-                ident,
-                generic: Some(generic),
-            }) if ident == RESULT_IDENT => Some(IrFuncOutput::ResultType(
-                self.type_parser.convert_to_ir_type(*generic)?,
-            )),
+            ty::SupportedInnerType::Path(ty::SupportedPathType { ident, mut generic })
+                if ident == RESULT_IDENT && !generic.is_empty() =>
+            {
+                let first_argument = self
+                    .type_parser
+                    .convert_to_ir_type(generic.remove(0))
+                    .unwrap();
+                let second_argument = if generic.len() == 1 {
+                    Some(
+                        self.type_parser
+                            .convert_to_ir_type(generic.remove(0))
+                            .unwrap(),
+                    )
+                } else {
+                    None
+                };
+                Some(IrFuncOutput::ResultType(first_argument, second_argument))
+            }
             _ => Some(IrFuncOutput::Type(
                 self.type_parser.convert_to_ir_type(inner)?,
             )),
@@ -112,6 +124,7 @@ impl<'a> Parser<'a> {
 
         let mut inputs = Vec::new();
         let mut output = None;
+        let mut error_output = None;
         let mut mode: Option<IrFuncMode> = None;
         let mut fallible = true;
 
@@ -147,26 +160,26 @@ impl<'a> Parser<'a> {
         }
 
         if output.is_none() {
-            output = Some(match &sig.output {
+            (output, error_output) = match &sig.output {
                 ReturnType::Type(_, ty) => {
                     match self.try_parse_fn_output_type(ty).unwrap_or_else(|| {
                         panic!(
                             "Failed to parse function output type `{}`",
                             type_to_string(ty)
                         )
                     }) {
-                        IrFuncOutput::ResultType(ty) => ty,
+                        IrFuncOutput::ResultType(ty, err) => (Some(ty), err),
                         IrFuncOutput::Type(ty) => {
                             fallible = false;
-                            ty
+                            (Some(ty), None)
                         }
                     }
                 }
                 ReturnType::Default => {
                     fallible = false;
-                    IrType::Primitive(IrTypePrimitive::Unit)
+                    (Some(IrType::Primitive(IrTypePrimitive::Unit)), None)
                 }
-            });
+            };
             mode = Some(
                 if let Some(IrType::Delegate(IrTypeDelegate::SyncReturnVecU8)) = output {
                     IrFuncMode::Sync
@@ -180,6 +193,7 @@ impl<'a> Parser<'a> {
             name: func_name,
             inputs,
             output: output.expect("unsupported output"),
+            error_output,
             fallible,
             mode: mode.expect("missing mode"),
             comments: extract_comments(&func.attrs),

frb_codegen/src/parser/ty.rs

@@ -70,14 +70,14 @@ impl std::fmt::Display for SupportedInnerType {
 #[derive(Debug)]
 pub struct SupportedPathType {
     pub ident: syn::Ident,
-    pub generic: Option<Box<SupportedInnerType>>,
+    pub generic: Vec<SupportedInnerType>,
 }
 
 impl std::fmt::Display for SupportedPathType {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let ident = self.ident.to_string();
-        if let Some(generic) = &self.generic {
-            write!(f, "{}<{}>", ident, generic)
+        if !self.generic.is_empty() {
+            write!(f, "{}<{:?}>", ident, self.generic)
         } else {
             write!(f, "{}", ident)
         }
@@ -94,19 +94,20 @@ impl SupportedInnerType {
                 match last_segment.arguments {
                     syn::PathArguments::None => Some(SupportedInnerType::Path(SupportedPathType {
                         ident: last_segment.ident,
-                        generic: None,
+                        generic: Vec::new(),
                     })),
                     syn::PathArguments::AngleBracketed(a) => {
-                        let generic = match a.args.into_iter().next() {
-                            Some(syn::GenericArgument::Type(t)) => {
-                                Some(Box::new(SupportedInnerType::try_from_syn_type(&t)?))
+                        let args = a.args.into_iter().collect::<Vec<GenericArgument>>();
+                        let mut supported_inner_types: Vec<SupportedInnerType> = Vec::new();
+                        for arg in args {
+                            if let syn::GenericArgument::Type(t) = arg {
+                                supported_inner_types
+                                    .push(SupportedInnerType::try_from_syn_type(&t).unwrap());
                             }
-                            _ => None,
-                        };
-
+                        }
                         Some(SupportedInnerType::Path(SupportedPathType {
                             ident: last_segment.ident,
-                            generic,
+                            generic: supported_inner_types,
                         }))
                     }
                     _ => None,
@@ -166,48 +167,49 @@ impl<'a> TypeParser<'a> {
     }
 
     /// Converts a path type into an `IrType` if possible.
-    pub fn convert_path_to_ir_type(&mut self, p: SupportedPathType) -> Option<IrType> {
+    pub fn convert_path_to_ir_type(&mut self, mut p: SupportedPathType) -> Option<IrType> {
         let p_as_str = format!("{}", &p);
         let ident_string = &p.ident.to_string();
-        if let Some(generic) = p.generic {
+        if !p.generic.is_empty() {
             match ident_string.as_str() {
                 "SyncReturn" => {
                     // Special-case SyncReturn<Vec<u8>>. SyncReturn for any other type is not
                     // supported.
-                    match *generic {
-                        SupportedInnerType::Path(SupportedPathType {
-                            ident,
-                            generic: Some(generic),
-                        }) if ident == "Vec" => match *generic {
-                            SupportedInnerType::Path(SupportedPathType {
-                                ident,
-                                generic: None,
-                            }) if ident == "u8" => {
-                                Some(IrType::Delegate(IrTypeDelegate::SyncReturnVecU8))
+                    match &p.generic[0] {
+                        SupportedInnerType::Path(SupportedPathType { ident, generic })
+                            if ident == "Vec" && !generic.is_empty() =>
+                        {
+                            match &generic[0] {
+                                SupportedInnerType::Path(SupportedPathType { ident, generic })
+                                    if ident == "u8" && generic.is_empty() =>
+                                {
+                                    Some(IrType::Delegate(IrTypeDelegate::SyncReturnVecU8))
+                                }
+                                _ => None,
                             }
-                            _ => None,
-                        },
+                        }
                         _ => None,
                     }
                 }
                 "Vec" => {
                     // Special-case Vec<String> as StringList
-                    if matches!(*generic, SupportedInnerType::Path(SupportedPathType { ref ident, .. }) if ident == "String")
+                    if matches!(p.generic[0], SupportedInnerType::Path(SupportedPathType { ref ident, .. }) if ident == "String")
                     {
                         Some(IrType::Delegate(IrTypeDelegate::StringList))
                     } else {
-                        self.convert_to_ir_type(*generic).map(|inner| match inner {
-                            Primitive(primitive) => {
-                                PrimitiveList(IrTypePrimitiveList { primitive })
-                            }
-                            others => GeneralList(IrTypeGeneralList {
-                                inner: Box::new(others),
-                            }),
-                        })
+                        self.convert_to_ir_type(p.generic.remove(0))
+                            .map(|inner| match inner {
+                                Primitive(primitive) => {
+                                    PrimitiveList(IrTypePrimitiveList { primitive })
+                                }
+                                others => GeneralList(IrTypeGeneralList {
+                                    inner: Box::new(others),
+                                }),
+                            })
                     }
                 }
                 "ZeroCopyBuffer" => {
-                    let inner = self.convert_to_ir_type(*generic);
+                    let inner = self.convert_to_ir_type(p.generic.remove(0));
                     if let Some(IrType::PrimitiveList(IrTypePrimitiveList { primitive })) = inner {
                         Some(IrType::Delegate(
                             IrTypeDelegate::ZeroCopyBufferVecPrimitive(primitive),
@@ -216,31 +218,32 @@ impl<'a> TypeParser<'a> {
                         None
                     }
                 }
-                "Box" => self.convert_to_ir_type(*generic).map(|inner| {
+                "Box" => self.convert_to_ir_type(p.generic.remove(0)).map(|inner| {
                     Boxed(IrTypeBoxed {
                         exist_in_real_api: true,
                         inner: Box::new(inner),
                     })
                 }),
                 "Option" => {
                     // Disallow nested Option
-                    if matches!(*generic, SupportedInnerType::Path(SupportedPathType { ref ident, .. }) if ident == "Option")
+                    if matches!(p.generic[0], SupportedInnerType::Path(SupportedPathType { ref ident, .. }) if ident == "Option")
                     {
                         panic!(
                             "Nested optionals without indirection are not supported. (Option<Option<{}>>)",
                             p_as_str
                         );
                     }
-                    self.convert_to_ir_type(*generic).map(|inner| match inner {
-                        Primitive(prim) => IrType::Optional(IrTypeOptional::new_prim(prim)),
-                        st @ StructRef(_) => {
-                            IrType::Optional(IrTypeOptional::new_ptr(Boxed(IrTypeBoxed {
-                                inner: Box::new(st),
-                                exist_in_real_api: false,
-                            })))
-                        }
-                        other => IrType::Optional(IrTypeOptional::new_ptr(other)),
-                    })
+                    self.convert_to_ir_type(p.generic.remove(0))
+                        .map(|inner| match inner {
+                            Primitive(prim) => IrType::Optional(IrTypeOptional::new_prim(prim)),
+                            st @ StructRef(_) => {
+                                IrType::Optional(IrTypeOptional::new_ptr(Boxed(IrTypeBoxed {
+                                    inner: Box::new(st),
+                                    exist_in_real_api: false,
+                                })))
+                            }
+                            other => IrType::Optional(IrTypeOptional::new_ptr(other)),
+                        })
                 }
                 _ => None,
             }