fix handling of skip/default in several places

Author: knickish

derive/src/serde_bin.rs

@@ -3,7 +3,7 @@ use alloc::string::String;
 
 use crate::{
     parse::{Category, Enum, Struct, Type},
-    shared::{enum_bounds_strings, struct_bounds_strings},
+    shared::{attrs_skip, enum_bounds_strings, struct_bounds_strings},
 };
 
 use proc_macro::TokenStream;
@@ -41,7 +41,7 @@ pub fn derive_ser_bin_struct(struct_: &Struct, crate_name: &str) -> TokenStream
     let (generic_w_bounds, generic_no_bounds) =
         struct_bounds_strings(struct_, "SerBin", crate_name);
 
-    for field in &struct_.fields {
+    for field in struct_.fields.iter().filter(|f| !attrs_skip(&f.attributes)) {
         if let Some(proxy) = crate::shared::attrs_proxy(&field.attributes) {
             l!(
                 body,
@@ -82,14 +82,20 @@ pub fn derive_ser_bin_struct_unnamed(struct_: &Struct, crate_name: &str) -> Toke
     let (generic_w_bounds, generic_no_bounds) =
         struct_bounds_strings(struct_, "SerBin", crate_name);
 
-    for (n, field) in struct_.fields.iter().enumerate() {
+    for (n, field) in struct_
+        .fields
+        .iter()
+        .enumerate()
+        .filter(|(_, f)| !attrs_skip(&f.attributes))
+    {
         if let Some(proxy) = crate::shared::attrs_proxy(&field.attributes) {
             l!(body, "let proxy: {} = Into::into(&self.{});", proxy, n);
             l!(body, "proxy.ser_bin(s);");
         } else {
             l!(body, "self.{}.ser_bin(s);", n);
         }
     }
+
     format!(
         "impl{} {}::SerBin for {}{} {{
             fn ser_bin(&self, s: &mut Vec<u8>) {{
@@ -113,7 +119,7 @@ pub fn derive_de_bin_struct(struct_: &Struct, crate_name: &str) -> TokenStream {
     let mut body = String::new();
     let (generic_w_bounds, generic_no_bounds) = struct_bounds_strings(struct_, "DeBin", crate_name);
 
-    for field in &struct_.fields {
+    for field in struct_.fields.iter().filter(|f| !attrs_skip(&f.attributes)) {
         if let Some(proxy) = crate::shared::attrs_proxy(&field.attributes) {
             l!(body, "{}: {{", field.field_name.as_ref().unwrap());
             l!(
@@ -134,6 +140,14 @@ pub fn derive_de_bin_struct(struct_: &Struct, crate_name: &str) -> TokenStream {
         }
     }
 
+    for field in struct_.fields.iter().filter(|f| attrs_skip(&f.attributes)) {
+        l!(
+            body,
+            "{}: Default::default(),",
+            field.field_name.as_ref().unwrap()
+        );
+    }
+
     format!(
         "impl{} {}::DeBin for {}{} {{
             fn de_bin(o:&mut usize, d:&[u8]) -> ::core::result::Result<Self, {}::DeBinErr> {{
@@ -160,7 +174,12 @@ pub fn derive_de_bin_struct_unnamed(struct_: &Struct, crate_name: &str) -> Token
     let mut body = String::new();
     let (generic_w_bounds, generic_no_bounds) = struct_bounds_strings(struct_, "DeBin", crate_name);
 
-    for (n, field) in struct_.fields.iter().enumerate() {
+    for (n, field) in struct_
+        .fields
+        .iter()
+        .enumerate()
+        .filter(|(_, f)| !attrs_skip(&f.attributes))
+    {
         if let Some(proxy) = crate::shared::attrs_proxy(&field.attributes) {
             l!(body, "{}: {{", n);
             l!(
@@ -176,6 +195,14 @@ pub fn derive_de_bin_struct_unnamed(struct_: &Struct, crate_name: &str) -> Token
         }
     }
 
+    for field in struct_.fields.iter().filter(|f| attrs_skip(&f.attributes)) {
+        l!(
+            body,
+            "{}: Default::default(),",
+            field.field_name.as_ref().unwrap()
+        );
+    }
+
     format!(
         "impl{} {}::DeBin for {}{} {{
             fn de_bin(o:&mut usize, d:&[u8]) -> ::core::result::Result<Self, {}::DeBinErr> {{

derive/src/serde_ron.rs

@@ -6,7 +6,7 @@ use crate::parse::{Attribute, Category, Enum, Field, Struct, Type};
 
 use proc_macro::TokenStream;
 
-use crate::shared;
+use crate::shared::{self, attrs_skip};
 
 pub fn derive_ser_ron_proxy(proxy_type: &str, type_: &str, crate_name: &str) -> TokenStream {
     format!(
@@ -39,7 +39,7 @@ pub fn derive_de_ron_proxy(proxy_type: &str, type_: &str, crate_name: &str) -> T
 pub fn derive_ser_ron_struct(struct_: &Struct, crate_name: &str) -> TokenStream {
     let mut s = String::new();
 
-    for field in &struct_.fields {
+    for field in struct_.fields.iter().filter(|f| !attrs_skip(&f.attributes)) {
         let struct_fieldname = field.field_name.clone().unwrap();
         let ron_fieldname =
             shared::attrs_rename(&field.attributes).unwrap_or_else(|| struct_fieldname.clone());
@@ -96,7 +96,12 @@ pub fn derive_ser_ron_struct_unnamed(struct_: &Struct, crate_name: &str) -> Toke
     let mut body = String::new();
 
     let last = struct_.fields.len() - 1;
-    for (n, _) in struct_.fields.iter().enumerate() {
+    for (n, _field) in struct_
+        .fields
+        .iter()
+        .enumerate()
+        .filter(|(_, f)| !attrs_skip(&f.attributes))
+    {
         l!(body, "self.{}.ser_ron(d, s);", n);
         if n != last {
             l!(body, "s.out.push_str(\", \");");
@@ -136,9 +141,11 @@ pub fn derive_de_ron_named(
     let container_attr_default = shared::attrs_default(attributes).is_some();
 
     let mut unwraps = Vec::new();
-    for field in fields {
+    for field in fields.iter() {
         let struct_fieldname = field.field_name.as_ref().unwrap().to_string();
         let localvar = format!("_{}", struct_fieldname);
+        let field_is_option = field.ty.base() == "Option";
+        let field_attr_skip = shared::attrs_skip(&field.attributes);
         let field_attr_default = shared::attrs_default(&field.attributes);
         let field_attr_default_with = shared::attrs_default_with(&field.attributes);
         let default_val = if let Some(v) = field_attr_default {
@@ -149,40 +156,28 @@ pub fn derive_de_ron_named(
                     val = format!("Some({})", val);
                 }
                 Some(val)
-            } else if field.ty.base() != "Option" {
+            } else if !field_is_option {
                 Some(String::from("Default::default()"))
             } else {
                 Some(String::from("None"))
             }
         } else if let Some(mut v) = field_attr_default_with {
             v.push_str("()");
             Some(v)
+        } else if container_attr_default || field_attr_skip || field_is_option {
+            Some(String::from("Default::default()"))
         } else {
             None
         };
-        let ron_fieldname =
-            shared::attrs_rename(&field.attributes).unwrap_or(struct_fieldname.clone());
-        let skip = crate::shared::attrs_skip(&field.attributes);
-
-        if !skip {
-            if field.ty.base() == "Option" || container_attr_default || default_val.is_some() {
-                if let Some(default_val) = default_val {
-                    unwraps.push(format!("{}.unwrap_or_else(|| {})", localvar, default_val));
-                } else {
-                    unwraps.push(format!("{}.unwrap_or_default()", localvar));
-                }
-            } else {
-                unwraps.push(format!(
-                    "{}.ok_or_else(|| s.err_nf(\"{}\"))?",
-                    localvar, struct_fieldname
-                ));
-            }
-        } else {
-            unwraps.push(format!(
-                "{{ {} }}",
-                default_val.as_deref().unwrap_or("Default::default()")
-            ));
-        }
+        let ron_fieldname =(!field_attr_skip).then(|| shared::attrs_rename(&field.attributes).unwrap_or(struct_fieldname.clone()));
+
+        unwraps.push(match default_val {
+            Some(def) => format!("{}.unwrap_or_else(|| {})", localvar, def),
+            None => format!(
+                "{}.ok_or_else(|| s.err_nf(\"{}\"))?",
+                localvar, struct_fieldname
+            ),
+        });
 
         struct_field_names.push(struct_fieldname);
         ron_field_names.push(ron_fieldname);
@@ -203,6 +198,9 @@ pub fn derive_de_ron_named(
     let match_names = if !ron_field_names.is_empty() {
         let mut inner = String::new();
         for (ron_field_name, (local_var, _)) in ron_field_names.iter().zip(local_vars.iter()) {
+            let Some(ron_field_name) = ron_field_name else {
+                continue;
+            };
             l!(
                 inner,
                 "\"{}\" => {{

tests/bin.rs

@@ -34,7 +34,7 @@ fn binary() {
 
 #[test]
 fn binary_generics() {
-    #[derive(DeBin, SerBin, PartialEq)]
+    #[derive(DeBin, SerBin, PartialEq, Debug)]
     struct TestGenericsWSkip<A, B, C, DD: Eq + Ord, EE>
     where
         EE: Eq + Ord,
@@ -57,9 +57,12 @@ fn binary_generics() {
 
     let bytes = SerBin::serialize_bin(&test);
 
-    let test_deserialized = DeBin::deserialize_bin(&bytes).unwrap();
+    let mut test_deserialized = DeBin::deserialize_bin(&bytes).unwrap();
 
-    assert!(test == test_deserialized);
+    // show that everything is equal, except for the skipped field
+    assert_ne!(test, test_deserialized);
+    test_deserialized.test4 = test.test4.clone();
+    assert_eq!(test, test_deserialized);
 
     #[derive(DeBin, SerBin, PartialEq)]
     pub enum TestEnum<A, B> {

tests/ser_de.rs

@@ -31,7 +31,7 @@ fn ser_de() {
         f: Option<([u32; 4], String)>,
         g: (),
         h: f64,
-        #[nserde(skip)]
+        #[nserde(skip, default)]
         i: Test2,
     }
 
@@ -47,7 +47,7 @@ fn ser_de() {
         f: Some(([1, 2, 3, 4], "tuple".to_string())),
         g: (),
         h: 1e30,
-        i: Default::default()
+        i: Default::default(),
     };
 
     #[cfg(feature = "binary")]