Implement Lift for flat errors

We noticed a regression in `0.25.x` where dictionaries containing flat
errors caused code not to be compiled.  We never officially supported
compound types that stored errors, but it seems better to allow the code
to compile in this case.

The reason this isn't supported is that we can't lift flat errors, so
therefore we can't lift the dictionary.  A better fix for this would be
to not implement `Lift` on the dictionary in this case, which would
cause a compile error rather than a runtime panic.  However, that's
actually not so simple as noted in the comment so I went for an easier
way.

This brings this very close to how they worked in `0.24.x` where we
would generate an `FfiConverter` implementation for flat errors, but the
lift half of it would just be panics.

Author: bendk

fixtures/coverall/src/coverall.udl

@@ -22,6 +22,9 @@ namespace coverall {
     void test_getters(Getters g);
 
     sequence<string> ancestor_names(NodeTrait node);
+
+    ReturnOnlyDict output_return_only_dict();
+    ReturnOnlyEnum output_return_only_enum();
 };
 
 dictionary SimpleDict {
@@ -49,6 +52,21 @@ dictionary SimpleDict {
     NodeTrait? test_trait;
 };
 
+// Create a type that stores `CoverallFlatError` and therefore can only be lowered but not lifted.
+// UniFFI should define a `Lower` implemenation but not try to define `Lift`.
+dictionary ReturnOnlyDict {
+    CoverallFlatError e;
+};
+
+// More complicated version of the above, each variant is return-only for different reasons
+[Enum]
+interface ReturnOnlyEnum {
+    One(CoverallFlatError e);
+    Two(ReturnOnlyDict d);
+    Three(sequence<CoverallFlatError> l);
+    Four(record<string, CoverallFlatError> m);
+};
+
 dictionary DictWithDefaults {
     string name = "default-value";
     string? category = null;

fixtures/coverall/src/lib.rs

@@ -134,6 +134,37 @@ pub struct SimpleDict {
     test_trait: Option<Arc<dyn NodeTrait>>,
 }
 
+pub struct ReturnOnlyDict {
+    e: CoverallFlatError,
+}
+
+pub enum ReturnOnlyEnum {
+    One {
+        e: CoverallFlatError,
+    },
+    Two {
+        d: ReturnOnlyDict,
+    },
+    Three {
+        l: Vec<CoverallFlatError>,
+    },
+    Four {
+        m: HashMap<String, CoverallFlatError>,
+    },
+}
+
+fn output_return_only_dict() -> ReturnOnlyDict {
+    ReturnOnlyDict {
+        e: CoverallFlatError::TooManyVariants { num: 1 },
+    }
+}
+
+fn output_return_only_enum() -> ReturnOnlyEnum {
+    ReturnOnlyEnum::One {
+        e: CoverallFlatError::TooManyVariants { num: 2 },
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct DictWithDefaults {
     name: String,

uniffi_macros/src/error.rs

@@ -87,6 +87,7 @@ fn flat_error_ffi_converter_impl(
 ) -> TokenStream {
     let name = ident_to_string(ident);
     let lower_impl_spec = tagged_impl_header("Lower", ident, udl_mode);
+    let lift_impl_spec = tagged_impl_header("Lift", ident, udl_mode);
     let derive_ffi_traits = derive_ffi_traits(ident, udl_mode, &["ConvertError"]);
     let mod_path = match mod_path() {
         Ok(p) => p,
@@ -124,11 +125,11 @@ fn flat_error_ffi_converter_impl(
                     .concat_str(#mod_path)
                     .concat_str(#name);
             }
+
         }
     };
 
-    let lift_impl = implement_lift.then(|| {
-        let lift_impl_spec = tagged_impl_header("Lift", ident, udl_mode);
+    let lift_impl = if implement_lift {
         let match_arms = enum_.variants.iter().enumerate().map(|(i, v)| {
             let v_ident = &v.ident;
             let idx = Index::from(i + 1);
@@ -157,7 +158,31 @@ fn flat_error_ffi_converter_impl(
             }
 
         }
-    });
+    } else {
+        quote! {
+            // Lifting flat errors is not currently supported, but we still define the trait so
+            // that dicts containing flat errors don't cause compile errors (see ReturnOnlyDict in
+            // coverall.rs).
+            //
+            // Note: it would be better to not derive `Lift` for dictionaries containing flat
+            // errors, but getting the trait bounds and derived impls there would be much harder.
+            // For now, we just fail at runtime.
+            #[automatically_derived]
+            unsafe #lift_impl_spec {
+                type FfiType = ::uniffi::RustBuffer;
+
+                fn try_read(buf: &mut &[::std::primitive::u8]) -> ::uniffi::deps::anyhow::Result<Self> {
+                    panic!("Can't lift flat errors")
+                }
+
+                fn try_lift(v: ::uniffi::RustBuffer) -> ::uniffi::deps::anyhow::Result<Self> {
+                    panic!("Can't lift flat errors")
+                }
+
+                const TYPE_ID_META: ::uniffi::MetadataBuffer = <Self as ::uniffi::Lower<crate::UniFfiTag>>::TYPE_ID_META;
+            }
+        }
+    };
 
     quote! {
         #lower_impl