Updating the LiftReturn trait to handle foreign trait interface

I'm hoping that we can implement trait interfaces differently than
callback interfaces.  I want the foreign impl of a trait method to
exactly like the Rust scaffolding code: input a `&mut RustCallStatus` as
an out param and return the FFI type.

uniffi_core/src/ffi/callbackinterface.rs

@@ -186,7 +186,7 @@ impl ForeignCallbackInternals {
             .unwrap_or_else(|code| panic!("Callback failed with unexpected return code: {code}"));
         match result {
             CallbackResult::Success => R::lift_callback_return(ret_rbuf),
-            CallbackResult::Error => R::lift_callback_error(ret_rbuf),
+            CallbackResult::Error => R::lift_error(ret_rbuf),
             CallbackResult::UnexpectedError => {
                 let reason = if !ret_rbuf.is_empty() {
                     match <String as Lift<UniFfiTag>>::try_lift(ret_rbuf) {
@@ -216,8 +216,10 @@ pub struct UnexpectedUniFFICallbackError {
 }
 
 impl UnexpectedUniFFICallbackError {
-    pub fn from_reason(reason: String) -> Self {
-        Self { reason }
+    pub fn new(reason: impl fmt::Display) -> Self {
+        Self {
+            reason: reason.to_string(),
+        }
     }
 }
 

uniffi_core/src/ffi/rustcalls.rs

@@ -56,6 +56,13 @@ pub struct RustCallStatus {
 }
 
 impl RustCallStatus {
+    pub fn new() -> Self {
+        Self {
+            code: RustCallStatusCode::Success,
+            error_buf: MaybeUninit::new(RustBuffer::new()),
+        }
+    }
+
     pub fn cancelled() -> Self {
         Self {
             code: RustCallStatusCode::Cancelled,

uniffi_core/src/ffi_converter_impls.rs

@@ -498,6 +498,12 @@ unsafe impl<UT> LowerReturn<UT> for () {
 }
 
 unsafe impl<UT> LiftReturn<UT> for () {
+    type ReturnType = ();
+
+    fn try_lift_successful_return(_: ()) -> Result<Self> {
+        Ok(())
+    }
+
     fn lift_callback_return(_buf: RustBuffer) -> Self {}
 
     const TYPE_ID_META: MetadataBuffer = MetadataBuffer::from_code(metadata::codes::TYPE_UNIT);
@@ -535,13 +541,19 @@ where
 unsafe impl<UT, R, E> LiftReturn<UT> for Result<R, E>
 where
     R: LiftReturn<UT>,
-    E: Lift<UT> + From<UnexpectedUniFFICallbackError>,
+    E: Lift<UT, FfiType = RustBuffer> + From<UnexpectedUniFFICallbackError>,
 {
+    type ReturnType = R::ReturnType;
+
+    fn try_lift_successful_return(v: R::ReturnType) -> Result<Self> {
+        R::try_lift_successful_return(v).map(Ok)
+    }
+
     fn lift_callback_return(buf: RustBuffer) -> Self {
         Ok(R::lift_callback_return(buf))
     }
 
-    fn lift_callback_error(buf: RustBuffer) -> Self {
+    fn lift_error(buf: RustBuffer) -> Self {
         match E::try_lift_from_rust_buffer(buf) {
             Ok(lifted_error) => Err(lifted_error),
             Err(anyhow_error) => {

uniffi_core/src/ffi_converter_traits.rs

@@ -51,7 +51,10 @@ use std::{borrow::Borrow, sync::Arc};
 use anyhow::bail;
 use bytes::Buf;
 
-use crate::{FfiDefault, MetadataBuffer, Result, RustBuffer, UnexpectedUniFFICallbackError};
+use crate::{
+    FfiDefault, MetadataBuffer, Result, RustBuffer, RustCallStatus, RustCallStatusCode,
+    UnexpectedUniFFICallbackError,
+};
 
 /// Generalized FFI conversions
 ///
@@ -302,14 +305,44 @@ pub unsafe trait LowerReturn<UT>: Sized {
 /// These traits should not be used directly, only in generated code, and the generated code should
 /// have fixture tests to test that everything works correctly together.
 pub unsafe trait LiftReturn<UT>: Sized {
+    /// FFI return type for trait interfaces
+    type ReturnType;
+
+    /// Lift a successfully returned value from a trait interface
+    fn try_lift_successful_return(v: Self::ReturnType) -> Result<Self>;
+
+    /// Lift a foreign returned value from a trait interface
+    ///
+    /// When we call a foreign-implemented trait interface method, we pass a &mut RustCallStatus
+    /// and get [Self::ReturnType] returned.  This method takes both of those and lifts `Self` from
+    /// it.
+    fn lift_foreign_return(ffi_return: Self::ReturnType, call_status: RustCallStatus) -> Self {
+        match call_status.code {
+            RustCallStatusCode::Success => Self::try_lift_successful_return(ffi_return)
+                .unwrap_or_else(|e| {
+                    Self::handle_callback_unexpected_error(UnexpectedUniFFICallbackError::new(e))
+                }),
+            RustCallStatusCode::Error => {
+                Self::lift_error(unsafe { call_status.error_buf.assume_init() })
+            }
+            _ => {
+                let e = <String as FfiConverter<crate::UniFfiTag>>::try_lift(unsafe {
+                    call_status.error_buf.assume_init()
+                })
+                .unwrap_or_else(|e| format!("(Error lifting message: {e}"));
+                Self::handle_callback_unexpected_error(UnexpectedUniFFICallbackError::new(e))
+            }
+        }
+    }
+
     /// Lift a Rust value for a callback interface method result
     fn lift_callback_return(buf: RustBuffer) -> Self;
 
     /// Lift a Rust value for a callback interface method error result
     ///
     /// This is called for "expected errors" -- the callback method returns a Result<> type and the
     /// foreign code throws an exception that corresponds to the error type.
-    fn lift_callback_error(_buf: RustBuffer) -> Self {
+    fn lift_error(_buf: RustBuffer) -> Self {
         panic!("Callback interface method returned unexpected error")
     }
 
@@ -433,6 +466,12 @@ macro_rules! derive_ffi_traits {
     (impl $(<$($generic:ident),*>)? $(::uniffi::)? LiftReturn<$ut:path> for $ty:ty $(where $($where:tt)*)?) => {
         unsafe impl $(<$($generic),*>)* $crate::LiftReturn<$ut> for $ty $(where $($where)*)*
         {
+            type ReturnType = <Self as $crate::Lift<$ut>>::FfiType;
+
+            fn try_lift_successful_return(v: Self::ReturnType) -> $crate::Result<Self> {
+                <Self as $crate::Lift<$ut>>::try_lift(v)
+            }
+
             fn lift_callback_return(buf: $crate::RustBuffer) -> Self {
                 <Self as $crate::Lift<$ut>>::try_lift_from_rust_buffer(buf)
                     .expect("Error reading callback interface result")