Support Type::Custom{ builtin: Enum|Object, .. } as throws type (#2658)

Author: flisky

CHANGELOG.md

@@ -20,6 +20,7 @@
   without a literal) meaning the default value for the type. Named types can also have a default.
   ([#2543](https://github.com/mozilla/uniffi-rs/pull/2543))
 - Custom types support the default value, and specified as its "bridge" type ([#2603](https://github.com/mozilla/uniffi-rs/pull/2603))
+- Custom `enum` and `object` types can be used as error type ([#2658](https://github.com/mozilla/uniffi-rs/pull/2658))
 - Objects can implement external traits ([#2430](https://github.com/mozilla/uniffi-rs/issues/2430))
 - `#[uniffi(default)]` literals are now optional - eg, `#[uniffi(default)]` and `#[uniffi(default = 0)]` are equivalent.
   When no literal is specifed, named types (objects, records, etc) can be used as long as they have suitable default values.

fixtures/error-types/src/lib.rs

@@ -241,6 +241,32 @@ fn oops_tuple(i: u16) -> Result<(), TupleError> {
     }
 }
 
+#[derive(Debug)]
+struct CustomError(u16);
+
+impl std::fmt::Display for CustomError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+uniffi::custom_type!(CustomError, TupleError, {
+    try_lift: |val| {
+        let TupleError::Value(v) = val else {
+            return Err(anyhow::anyhow!("not a Value variant"));
+        };
+        Ok(CustomError(v))
+    },
+    lower: |val| {
+        TupleError::Value(val.0)
+    }
+});
+
+#[uniffi::export]
+fn oops_custom(i: u16) -> Result<(), CustomError> {
+    Err(CustomError(i))
+}
+
 #[uniffi::export(default(t = None))]
 fn get_tuple(t: Option<TupleError>) -> TupleError {
     t.unwrap_or_else(|| TupleError::Oops("oops".to_string()))

fixtures/error-types/tests/bindings/test.kts

@@ -103,6 +103,12 @@ try {
     assert(e.toString() == "uniffi.error_types.TupleException${'$'}Value: v1=1")
 }
 
+try {
+    oopsCustom(1u)
+    throw RuntimeException("Should have failed")
+} catch (e: TupleException) {
+}
+
 runBlocking {
     try {
         aoops()

fixtures/error-types/tests/bindings/test.py

@@ -130,5 +130,9 @@ def test_tuple_error(self):
         self.assertEqual(str(cm.exception), "1")
         self.assertEqual(repr(cm.exception), "TupleError.Value(1)")
 
+        # custom error type
+        with self.assertRaises(TupleError) as cm:
+            oops_custom(1)
+
 if __name__=='__main__':
     unittest.main()

fixtures/error-types/tests/bindings/test.swift

@@ -94,6 +94,12 @@ do {
     assert(error.localizedDescription == "error_types.TupleError.Value(1)")
 }
 
+do {
+    try oopsCustom(i: 1)
+    fatalError("Should have thrown")
+} catch {
+}
+
 do {
     try oopsNowrap()
     fatalError("Should have thrown")

uniffi_bindgen/src/bindings/python/pipeline/error.rs

@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use super::*;
+
+pub fn pass(cb: &mut Callable) -> Result<()> {
+    // normalize the custom type to its builtin type
+    if let Some(node) = cb.throws_type.ty.as_mut() {
+        if let Type::Custom { builtin, .. } = &node.ty {
+            node.ty = *builtin.clone();
+        }
+    }
+    Ok(())
+}

uniffi_bindgen/src/bindings/python/pipeline/mod.rs

@@ -9,6 +9,7 @@ use uniffi_pipeline::{Node, Pipeline};
 mod callback_interfaces;
 mod config;
 mod default;
+mod error;
 mod external_types;
 mod ffi_types;
 mod interfaces;
@@ -33,4 +34,5 @@ pub fn pipeline() -> Pipeline<initial::Root, Root> {
         .pass(types::pass)
         .pass(default::pass)
         .pass(ffi_types::pass)
+        .pass(error::pass)
 }

uniffi_bindgen/src/interface/mod.rs

@@ -1289,6 +1289,11 @@ fn throws_name(throws: &Option<Type>) -> Option<&str> {
     match throws {
         None => None,
         Some(Type::Enum { name, .. }) | Some(Type::Object { name, .. }) => Some(name),
+        Some(Type::Custom { name, builtin, .. })
+            if matches!(&**builtin, Type::Enum { .. } | Type::Object { .. }) =>
+        {
+            Some(name)
+        }
         _ => panic!("unknown throw type: {throws:?}"),
     }
 }