Don't require derive_more in the macro

we gen the from impls ourselves now.

Author: rklaehn

Cargo.lock

@@ -42,7 +42,7 @@ tracing-subscriber = { version = "0.3.19", features = ["fmt"] }
 # used in the derive example. This must not be a main crate dep or else it will be circular!
 quic-rpc-derive = { path = "quic-rpc-derive" }
 # just convenient for the enum definitions
-derive_more = { version = "2", features = ["debug", "display", "from"] }
+derive_more = { version = "2", features = ["from"] }
 # we need full for example main etc.
 tokio = { version = "1", features = ["full"] }
 # formatting

Cargo.toml

@@ -58,7 +58,7 @@ enum ComputeRequest {
 
 // Define the protocol and message enums using the macro
 #[rpc_requests(ComputeService, ComputeMessage)]
-#[derive(derive_more::From, Serialize, Deserialize)]
+#[derive(Serialize, Deserialize)]
 enum ComputeProtocol {
     #[rpc(tx=oneshot::Sender<u128>)]
     Sqr(Sqr),

examples/compute.rs

@@ -41,7 +41,7 @@ struct Set {
 // Use the macro to generate both the StorageProtocol and StorageMessage enums
 // plus implement Channels for each type
 #[rpc_requests(StorageService, StorageMessage)]
-#[derive(derive_more::From, Serialize, Deserialize)]
+#[derive(Serialize, Deserialize)]
 enum StorageProtocol {
     #[rpc(tx=oneshot::Sender<Option<String>>)]
     Get(Get),

examples/derive.rs

@@ -18,7 +18,7 @@ quote = "1"
 proc-macro2 = "1"
 
 [dev-dependencies]
-derive_more = { version = "1", features = ["from", "try_into", "display"] }
+derive_more = { version = "2", features = ["from"] }
 serde = { version = "1", features = ["serde_derive"] }
 trybuild = "1.0"
 quic-rpc = { path = ".." }

quic-rpc-derive/Cargo.toml

@@ -48,6 +48,35 @@ fn generate_channels_impl(
     args.check_empty(attr_span)?;
     Ok(res)
 }
+fn generate_from_impls(
+    message_enum_name: &Ident,
+    variants: &[(Ident, Type)],
+    service_name: &Ident,
+    original_enum_name: &Ident,
+    additional_items: &mut Vec<proc_macro2::TokenTree>,
+) {
+    // Generate and add From impls for the message enum
+    for (variant_name, inner_type) in variants {
+        let message_impl = quote! {
+            impl From<::quic_rpc::WithChannels<#inner_type, #service_name>> for #message_enum_name {
+                fn from(value: ::quic_rpc::WithChannels<#inner_type, #service_name>) -> Self {
+                    #message_enum_name::#variant_name(value)
+                }
+            }
+        };
+        additional_items.extend(message_impl);
+
+        // Generate and add From impls for the original enum
+        let original_impl = quote! {
+            impl From<#inner_type> for #original_enum_name {
+                fn from(value: #inner_type) -> Self {
+                    #original_enum_name::#variant_name(value)
+                }
+            }
+        };
+        additional_items.extend(original_impl);
+    }
+}
 
 #[proc_macro_attribute]
 pub fn rpc_requests(attr: TokenStream, item: TokenStream) -> TokenStream {
@@ -127,7 +156,7 @@ pub fn rpc_requests(attr: TokenStream, item: TokenStream) -> TokenStream {
     }
 
     let message_variants = variants
-        .into_iter()
+        .iter()
         .map(|(variant_name, inner_type)| {
             quote! {
                 #variant_name(::quic_rpc::WithChannels<#inner_type, #service_name>)
@@ -136,12 +165,20 @@ pub fn rpc_requests(attr: TokenStream, item: TokenStream) -> TokenStream {
         .collect::<Vec<_>>();
 
     let message_enum = quote! {
-        #[derive(derive_more::From)]
         enum #message_enum_name {
             #(#message_variants),*
         }
     };
 
+    // Generate the From implementations
+    generate_from_impls(
+        &message_enum_name,
+        &variants,
+        &service_name,
+        &input.ident,
+        &mut additional_items,
+    );
+
     let output = quote! {
         #input
 

quic-rpc-derive/src/lib.rs

@@ -35,7 +35,7 @@ fn simple() {
     struct Response4;
 
     #[rpc_requests(Service, RequestWithChannels)]
-    #[derive(Debug, Serialize, Deserialize, derive_more::From, derive_more::TryInto)]
+    #[derive(Debug, Serialize, Deserialize)]
     enum Request {
         #[rpc(tx=oneshot::Sender<()>)]
         Rpc(RpcRequest),

quic-rpc-derive/tests/smoke.rs

@@ -450,7 +450,7 @@ impl<M: Send + Sync + 'static, R, S: Service> ServiceSender<M, R, S> {
             Self::Remote(endpoint, addr, _) => {
                 let connection = endpoint
                     .connect(*addr, "localhost")
-                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?
+                    .map_err(io::Error::other)?
                     .await?;
                 let (send, recv) = connection.open_bi().await?;
                 Ok(ServiceRequest::Remote(rpc::RemoteRequest::new(send, recv)))