msg_socket: fix derive for empty named structs

This wouldn't work before:

    #[derive(MsgOnSocket)]
    enum Simple {
        A {} => {},
    }

1 files changed, 38 insertions, 5 deletions

diff --git a/msg_socket/msg_on_socket_derive/msg_on_socket_derive.rs b/msg_socket/msg_on_socket_derive/msg_on_socket_derive.rs
index 77fc7f5..86481cc 100644
--- a/msg_socket/msg_on_socket_derive/msg_on_socket_derive.rs
+++ b/msg_socket/msg_on_socket_derive/msg_on_socket_derive.rs
@@ -261,12 +261,12 @@ fn define_buffer_size_for_enum(name: &Ident, de: &DataEnum) -> TokenStream {
                 }
 
                 let v = quote! {
-                    #name::#variant_name { #(#tmp_names),* } => #(#tmp_names.msg_size())+*,
+                    #name::#variant_name { #(#tmp_names),* } => 0 #(+ #tmp_names.msg_size())*,
                 };
                 msg_size_match_variants.push(v);
 
                 let v = quote! {
-                    #name::#variant_name { #(#tmp_names),* } => #(#tmp_names.fd_count())+*,
+                    #name::#variant_name { #(#tmp_names),* } => 0 #(+ #tmp_names.fd_count())*,
                 };
                 fd_count_match_variants.push(v);
             }
@@ -608,7 +608,7 @@ fn write_to_buffer_and_move_offset(name: &Ident) -> TokenStream {
 
 #[cfg(test)]
 mod tests {
-    use super::define_uses_fd_for_enum;
+    use super::{define_buffer_size_for_enum, define_uses_fd_for_enum};
     use crate::msg_socket_impl;
     use quote::quote;
     use syn::{parse_quote, Data, DeriveInput};
@@ -631,6 +631,39 @@ mod tests {
     }
 
     #[test]
+    fn empty_named_variant_msg_size() {
+        let DeriveInput { ident, data, .. } = parse_quote! {
+            enum Simple {
+            A {},
+            }
+        };
+
+        let data = match data {
+            Data::Enum(data) => data,
+            _ => unreachable!(),
+        };
+
+        let expected = quote! {
+            fn msg_size(&self) -> usize {
+            1 + match self {
+                Simple::A {} => 0,
+            }
+            }
+
+            fn fd_count(&self) -> usize {
+            match self {
+                Simple::A {} => 0,
+            }
+            }
+        };
+
+        assert_eq!(
+            define_buffer_size_for_enum(&ident, &data).to_string(),
+            expected.to_string(),
+        );
+    }
+
+    #[test]
     fn end_to_end_struct_test() {
         let input: DeriveInput = parse_quote! {
             struct MyMsg {
@@ -793,14 +826,14 @@ mod tests {
                     1 + match self {
                         MyMsg::A(enum_field0) => enum_field0.msg_size(),
                         MyMsg::B => 0,
-                        MyMsg::C { f0, f1 } => f0.msg_size() + f1.msg_size(),
+                        MyMsg::C { f0, f1 } => 0 + f0.msg_size() + f1.msg_size(),
                     }
                 }
                 fn fd_count(&self) -> usize {
                     match self {
                         MyMsg::A(enum_field0) => enum_field0.fd_count(),
                         MyMsg::B => 0,
-                        MyMsg::C { f0, f1 } => f0.fd_count() + f1.fd_count(),
+                        MyMsg::C { f0, f1 } => 0 + f0.fd_count() + f1.fd_count(),
                     }
                 }
                 unsafe fn read_from_buffer(