Merge pull request #176 from zeenix/error-borrows

✨ macros: Allow borrowing deserializer lifetime in ReplyError

Author: zeenix

zlink-core/src/connection/read_connection.rs

@@ -97,14 +97,15 @@ impl<Read: ReadHalf> ReadConnection<Read> {
     {
         #[derive(Debug, Deserialize)]
         #[serde(untagged)]
-        enum ReplyMsg<ReplyParams, ReplyError> {
-            Varlink(varlink_service::Error),
+        enum ReplyMsg<'m, ReplyParams, ReplyError> {
+            #[serde(borrow)]
+            Varlink(varlink_service::Error<'m>),
             Error(ReplyError),
             Reply(Reply<ReplyParams>),
         }
 
         let recv_result = self
-            .read_message::<ReplyMsg<ReplyParams, ReplyError>>()
+            .read_message::<ReplyMsg<'_, ReplyParams, ReplyError>>()
             .await?;
 
         #[cfg(feature = "std")]
@@ -114,7 +115,7 @@ impl<Read: ReadHalf> ReadConnection<Read> {
 
         let result = match msg {
             // Varlink service interface error need to be returned as the top-level error.
-            ReplyMsg::Varlink(e) => Err(crate::Error::VarlinkService(e)),
+            ReplyMsg::Varlink(e) => Err(crate::Error::VarlinkService(e.into_owned())),
             ReplyMsg::Error(e) => Ok(Err(e)),
             ReplyMsg::Reply(reply) => Ok(Ok(reply)),
         };

zlink-core/src/error.rs

@@ -25,7 +25,7 @@ pub enum Error {
     /// Missing required parameters.
     MissingParameters,
     /// A general service error.
-    VarlinkService(crate::varlink_service::Error),
+    VarlinkService(crate::varlink_service::Error<'static>),
 }
 
 /// The Result type for the zlink crate.

zlink-core/src/varlink_service/api.rs

@@ -1,4 +1,4 @@
-use alloc::string::String;
+use alloc::borrow::Cow;
 use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "introspection")]
@@ -46,40 +46,68 @@ pub enum Reply<'a> {
 #[cfg_attr(feature = "introspection", derive(introspect::ReplyError))]
 #[zlink(interface = "org.varlink.service")]
 #[cfg_attr(feature = "introspection", zlink(crate = "crate"))]
-pub enum Error {
+pub enum Error<'a> {
     /// The requested interface was not found.
     InterfaceNotFound {
         /// The interface that was not found.
-        interface: String,
+        #[zlink(borrow)]
+        interface: Cow<'a, str>,
     },
     /// The requested method was not found.
     MethodNotFound {
         /// The method that was not found.
-        method: String,
+        #[zlink(borrow)]
+        method: Cow<'a, str>,
     },
     /// The interface defines the requested method, but the service does not implement it.
     MethodNotImplemented {
         /// The method that is not implemented.
-        method: String,
+        #[zlink(borrow)]
+        method: Cow<'a, str>,
     },
     /// One of the passed parameters is invalid.
     InvalidParameter {
         /// The parameter that is invalid.
-        parameter: String,
+        #[zlink(borrow)]
+        parameter: Cow<'a, str>,
     },
     /// Client is denied access.
     PermissionDenied,
     /// Method is expected to be called with 'more' set to true, but wasn't.
     ExpectedMore,
 }
 
-impl core::error::Error for Error {
+impl Error<'_> {
+    /// Convert this error into an owned version with `'static` lifetime.
+    ///
+    /// This is useful when you need to store or propagate the error.
+    pub fn into_owned(self) -> Error<'static> {
+        match self {
+            Error::InterfaceNotFound { interface } => Error::InterfaceNotFound {
+                interface: Cow::Owned(interface.into_owned()),
+            },
+            Error::MethodNotFound { method } => Error::MethodNotFound {
+                method: Cow::Owned(method.into_owned()),
+            },
+            Error::MethodNotImplemented { method } => Error::MethodNotImplemented {
+                method: Cow::Owned(method.into_owned()),
+            },
+            Error::InvalidParameter { parameter } => Error::InvalidParameter {
+                parameter: Cow::Owned(parameter.into_owned()),
+            },
+            Error::PermissionDenied => Error::PermissionDenied,
+            Error::ExpectedMore => Error::ExpectedMore,
+        }
+    }
+}
+
+impl core::error::Error for Error<'_> {
     fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
         None
     }
 }
 
-impl core::fmt::Display for Error {
+impl core::fmt::Display for Error<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Error::InterfaceNotFound { interface } => {
@@ -105,17 +133,16 @@ impl core::fmt::Display for Error {
 }
 
 /// Result type for Varlink service methods.
-pub type Result<T> = core::result::Result<T, Error>;
+pub type Result<'a, T> = core::result::Result<T, Error<'a>>;
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use core::str::FromStr;
 
     #[test]
     fn error_serialization() {
         let err = Error::InterfaceNotFound {
-            interface: String::from_str("com.example.missing").unwrap(),
+            interface: Cow::Borrowed("com.example.missing"),
         };
 
         let json = serialize_error(&err);
@@ -130,86 +157,100 @@ mod tests {
 
     #[test]
     fn error_deserialization() {
-        // Test error with parameter
+        // Test error with parameter.
         let json = r#"{"error":"org.varlink.service.InterfaceNotFound","parameters":{"interface":"com.example.missing"}}"#;
-        let err = deserialize_error(json);
+        let err: Error<'_> = deserialize_error(json);
         assert_eq!(
             err,
             Error::InterfaceNotFound {
-                interface: String::from_str("com.example.missing").unwrap()
+                interface: Cow::Borrowed("com.example.missing")
             }
         );
 
-        // Test error without parameters
+        // Test error without parameters.
         let json = r#"{"error":"org.varlink.service.PermissionDenied"}"#;
-        let err = deserialize_error(json);
+        let err: Error<'_> = deserialize_error(json);
         assert_eq!(err, Error::PermissionDenied);
 
-        // Test MethodNotFound error
+        // Test MethodNotFound error.
         let json = r#"{"error":"org.varlink.service.MethodNotFound","parameters":{"method":"NonExistentMethod"}}"#;
-        let err = deserialize_error(json);
+        let err: Error<'_> = deserialize_error(json);
         assert_eq!(
             err,
             Error::MethodNotFound {
-                method: String::from_str("NonExistentMethod").unwrap()
+                method: Cow::Borrowed("NonExistentMethod")
             }
         );
 
-        // Test InvalidParameter error
+        // Test InvalidParameter error.
         let json = r#"{"error":"org.varlink.service.InvalidParameter","parameters":{"parameter":"invalid_param"}}"#;
-        let err = deserialize_error(json);
+        let err: Error<'_> = deserialize_error(json);
         assert_eq!(
             err,
             Error::InvalidParameter {
-                parameter: String::from_str("invalid_param").unwrap()
+                parameter: Cow::Borrowed("invalid_param")
             }
         );
 
-        // Test MethodNotImplemented error
+        // Test MethodNotImplemented error.
         let json = r#"{"error":"org.varlink.service.MethodNotImplemented","parameters":{"method":"UnimplementedMethod"}}"#;
-        let err = deserialize_error(json);
+        let err: Error<'_> = deserialize_error(json);
         assert_eq!(
             err,
             Error::MethodNotImplemented {
-                method: String::from_str("UnimplementedMethod").unwrap()
+                method: Cow::Borrowed("UnimplementedMethod")
             }
         );
 
-        // Test ExpectedMore error
+        // Test ExpectedMore error.
         let json = r#"{"error":"org.varlink.service.ExpectedMore"}"#;
-        let err = deserialize_error(json);
+        let err: Error<'_> = deserialize_error(json);
         assert_eq!(err, Error::ExpectedMore);
     }
 
     #[test]
     fn error_round_trip_serialization() {
-        // Test with error that has parameters
+        // Test with error that has parameters.
         let original = Error::InterfaceNotFound {
-            interface: String::from_str("com.example.missing").unwrap(),
+            interface: Cow::Borrowed("com.example.missing"),
         };
 
         test_round_trip_serialize(&original);
 
-        // Test with error that has no parameters
+        // Test with error that has no parameters.
         let original = Error::PermissionDenied;
 
         test_round_trip_serialize(&original);
     }
 
-    // Helper function to serialize Error to JSON string, abstracting std vs nostd differences
-    fn serialize_error(err: &Error) -> String {
+    #[test]
+    fn into_owned() {
+        let borrowed = Error::InterfaceNotFound {
+            interface: Cow::Borrowed("test.interface"),
+        };
+        let owned = borrowed.into_owned();
+        assert_eq!(
+            owned,
+            Error::InterfaceNotFound {
+                interface: Cow::Owned("test.interface".into())
+            }
+        );
+    }
+
+    // Helper function to serialize Error to JSON string.
+    fn serialize_error(err: &Error<'_>) -> String {
         serde_json::to_string(err).unwrap()
     }
 
-    // Helper function to deserialize JSON string to Error, abstracting std vs nostd differences
-    fn deserialize_error(json: &str) -> Error {
+    // Helper function to deserialize JSON string to Error.
+    fn deserialize_error(json: &str) -> Error<'_> {
         serde_json::from_str(json).unwrap()
     }
 
-    // Helper function for round-trip serialization test, abstracting std vs nostd differences
-    fn test_round_trip_serialize(original: &Error) {
+    // Helper function for round-trip serialization test.
+    fn test_round_trip_serialize(original: &Error<'_>) {
         let json = serde_json::to_string(original).unwrap();
-        let deserialized: Error = serde_json::from_str(&json).unwrap();
+        let deserialized: Error<'_> = serde_json::from_str(&json).unwrap();
         assert_eq!(*original, deserialized);
     }
 }

zlink-core/src/varlink_service/proxy.rs

@@ -29,7 +29,7 @@ use super::{Error, Info, InterfaceDescription};
 /// # let mut conn: Connection<zlink_core::connection::socket::impl_for_doc::Socket> = todo!();
 /// // For a single interface, use the provided Reply enum directly
 /// let chain = conn
-///     .chain_get_info::<Reply<'_>, Error>()?
+///     .chain_get_info::<Reply<'_>, Error<'_>>()?
 ///     .get_interface_description("org.example.interface")?
 ///     .get_info()?;
 ///
@@ -68,15 +68,16 @@ use super::{Error, Info, InterfaceDescription};
 ///
 /// #[derive(Debug, Deserialize)]
 /// #[serde(untagged)]
-/// enum CombinedError {
-///     VarlinkService(Error),
+/// enum CombinedError<'a> {
+///     #[serde(borrow)]
+///     VarlinkService(Error<'a>),
 ///     // Add other interface error types here
-///     // OtherInterface(other_interface::Error),
+///     // OtherInterface(other_interface::Error<'a>),
 /// }
 ///
 /// // Then use the combined types for cross-interface chaining
 /// let combined_chain = conn
-///     .chain_get_info::<CombinedReply<'_>, CombinedError>()?;
+///     .chain_get_info::<CombinedReply<'_>, CombinedError<'_>>()?;
 ///     // .other_interface_method()?;  // Chain calls from other interfaces
 ///
 /// let combined_replies = combined_chain.send().await?;
@@ -121,7 +122,7 @@ pub trait Proxy {
     ///
     /// Two-layer result: outer for connection errors, inner for method errors. On success, contains
     /// service information as [`Info`].
-    async fn get_info(&mut self) -> crate::Result<core::result::Result<Info<'_>, Error>>;
+    async fn get_info(&mut self) -> crate::Result<core::result::Result<Info<'_>, Error<'_>>>;
 
     /// Get the IDL description of an interface.
     ///
@@ -137,7 +138,7 @@ pub trait Proxy {
     async fn get_interface_description(
         &mut self,
         interface: &str,
-    ) -> crate::Result<core::result::Result<InterfaceDescription<'static>, Error>>;
+    ) -> crate::Result<core::result::Result<InterfaceDescription<'static>, Error<'_>>>;
 }
 
 #[cfg(test)]
@@ -159,10 +160,10 @@ mod tests {
         // Use the provided Reply enum from the varlink service module
         use super::{super::Reply, Error};
 
-        // Test that we can create the chain APIs
-        let _chain1 = conn.chain_get_info::<Reply<'_>, Error>()?;
+        // Test that we can create the chain APIs.
+        let _chain1 = conn.chain_get_info::<Reply<'_>, Error<'_>>()?;
         let _chain2 =
-            conn.chain_get_interface_description::<Reply<'_>, Error>("org.varlink.service")?;
+            conn.chain_get_interface_description::<Reply<'_>, Error<'_>>("org.varlink.service")?;
 
         Ok(())
     }
@@ -180,9 +181,9 @@ mod tests {
 
         use super::{super::Reply, Error};
 
-        // Test that we can chain calls using extension methods and actually read replies
+        // Test that we can chain calls using extension methods and actually read replies.
         let chained = conn
-            .chain_get_info::<Reply<'_>, Error>()?
+            .chain_get_info::<Reply<'_>, Error<'_>>()?
             .get_interface_description("org.varlink.service")?
             .get_info()?;