diff --git a/derive/src/difference.rs b/derive/src/difference.rs index 918a862..458d492 100644 --- a/derive/src/difference.rs +++ b/derive/src/difference.rs @@ -110,13 +110,20 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { let exposed = attrs_expose(&struct_.attributes); - let enum_name = match exposed.clone() { + // need a separate binding to the origin struct name for use in format_args + let base_name = match exposed { Some(Some(name)) => name, - Some(None) => struct_.name.as_ref().unwrap().to_string() + "StructDiffEnum", - _ => "__".to_owned() + struct_.name.as_ref().unwrap().as_str() + "StructDiffEnum", + Some(None) => struct_.name.as_ref().unwrap().as_str(), + _ => struct_.name.as_ref().unwrap().as_str(), }; - let struct_generics_names_hash: HashSet = + let enum_name = match exposed { + Some(Some(_)) => format_args!("{base_name}"), + Some(None) => format_args!("{}StructDiffEnum", base_name), + _ => format_args!("__{}StructDiffEnum", base_name), + }; + + let struct_generics_names_hash: HashSet<&str> = struct_.generics.iter().map(|x| x.full()).collect(); #[cfg(feature = "generated_setters")] @@ -131,10 +138,10 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { let field_name = field.field_name.as_ref().unwrap(); used_generics.extend(struct_.generics.iter().filter(|x| x.full() == field.ty.ident.path(&field.ty, false))); - let to_add = struct_.generics.iter().filter(|x| field.ty.wraps().iter().any(|wrapped_type| &x.full() == wrapped_type)); + let to_add = struct_.generics.iter().filter(|x| field.ty.wraps().iter().any(|wrapped_type| x.full() == wrapped_type)); used_generics.extend(to_add); - used_generics.extend(get_used_lifetimes(&field.ty).into_iter().filter_map(|x| match struct_generics_names_hash.contains(&x) { + used_generics.extend(get_used_lifetimes(&field.ty).into_iter().filter_map(|x| match struct_generics_names_hash.contains(x.as_str()) { true => Some(struct_.generics.iter().find(|generic| generic.full() == x ).unwrap()), false => None, })); @@ -875,7 +882,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { let nanoserde_hack = String::from("\nuse nanoserde::*;"); let used_generics = { - let mut added: HashSet = HashSet::new(); + let mut added: HashSet<&str> = HashSet::new(); let mut ret = Vec::new(); for maybe_used in struct_.generics.iter() { if added.insert(maybe_used.full()) && used_generics.contains(&maybe_used) { @@ -901,7 +908,9 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { let start = "\n#[serde(bound = \""; let mid = used_generics .iter() - .filter(|gen| !matches!(gen, Generic::Lifetime { .. } | Generic::Const { .. })) + .filter(|gen_type| { + !matches!(gen_type, Generic::Lifetime { .. } | Generic::Const { .. }) + }) .map(|x| { format!( "{}: serde::Serialize + serde::de::DeserializeOwned", @@ -932,7 +941,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { struct_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_with_const) .collect::>() .join(", "), @@ -943,19 +952,19 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { struct_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_only) .collect::>() .join(", "), struct_ .generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::Const { .. } | Generic::WhereBounded { .. } )) - .map(|gen| Generic::full_with_const( - gen, + .map(|gen_type| Generic::full_with_const( + gen_type, get_used_generic_bounds(), &[], true @@ -966,8 +975,8 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { struct_ .generics .iter() - .filter(|gen| matches!(gen, Generic::WhereBounded { .. })) - .map(|gen| Generic::full_with_const(gen, &[], &[], true)) + .filter(|gen_type| matches!(gen_type, Generic::WhereBounded { .. })) + .map(|gen_type| Generic::full_with_const(gen_type, &[], &[], true)) .collect::>() .into_iter() ) @@ -1073,7 +1082,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { "<{}>", used_generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_with_const) .collect::>() .join(", ") @@ -1083,7 +1092,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { std::iter::once(String::from("'__diff_target")).chain( used_generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_with_const)) .collect::>() .join(", ") @@ -1092,12 +1101,12 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { "{}", used_generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::WhereBounded { .. } | Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, false, true)) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds(), &[], true)) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds(), &[], true)) .collect::>() .join(",\n") ), @@ -1105,12 +1114,12 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { "{}", used_generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::WhereBounded { .. } | Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, true, true)) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds_ref(), &["\'__diff_target"], true)) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds_ref(), &["\'__diff_target"], true)) .chain(std::iter::once(String::from("Self: \'__diff_target"))) .collect::>() .join(",\n") @@ -1119,12 +1128,12 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { "{}", used_generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::WhereBounded { .. } | Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, true, true)) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds(), &["\'__diff_target"], true)) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds(), &["\'__diff_target"], true)) .collect::>() .join(",\n") ), @@ -1133,12 +1142,12 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { struct_ .generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::WhereBounded { .. } | Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, true, true)) - .map(|gen| Generic::full_with_const(gen, &[], &["\'__diff_target"], true)) + .map(|gen_type| Generic::full_with_const(gen_type, &[], &["\'__diff_target"], true)) .collect::>() .join(",\n") ), @@ -1147,7 +1156,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { struct_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_with_const) .collect::>() .join(", ") @@ -1157,7 +1166,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { struct_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_only) .collect::>() .join(", ") @@ -1167,21 +1176,21 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { struct_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::Const { .. } | Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::Const { .. } | Generic::WhereBounded { .. })) .filter(|g| Generic::has_where_bounds(g, false, true)) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds(), &[], true)) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds(), &[], true)) .collect::>().into_iter().chain(struct_ .generics .iter() - .filter(|gen| matches!(gen, Generic::WhereBounded { .. })) - .map(|gen| Generic::full_with_const(gen, &[], &[], true)).collect::>().into_iter()).collect::>() + .filter(|gen_type| matches!(gen_type, Generic::WhereBounded { .. })) + .map(|gen_type| Generic::full_with_const(gen_type, &[], &[], true)).collect::>().into_iter()).collect::>() .join(",\n") ), owned_enum_impl_generics = format_args!( "<{}>", used_generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_only) .collect::>() .join(", ") @@ -1191,7 +1200,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream { std::iter::once(String::from("'__diff_target")).chain( used_generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_only)) .collect::>() .join(", ") @@ -1241,17 +1250,24 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { let exposed = attrs_expose(&enum_.attributes); - let enum_name = match exposed.clone() { + // need a separate binding to the origin enum name for use in format_args + let base_name = match exposed { Some(Some(name)) => name, - Some(None) => enum_.name.clone() + "StructDiffEnum", - _ => "__".to_owned() + &enum_.name + "StructDiffEnum", + Some(None) => enum_.name.as_str(), + _ => enum_.name.as_str(), + }; + + let enum_name = match exposed { + Some(Some(_)) => format_args!("{base_name}"), + Some(None) => format_args!("{}StructDiffEnum", base_name), + _ => format_args!("__{}StructDiffEnum", base_name), }; let ref_into_owned_body = format!( "Self::Replace(variant) => {}::Replace(variant.clone()),", &enum_name ); - let struct_generics_names_hash: HashSet = + let struct_generics_names_hash: HashSet<&str> = enum_.generics.iter().map(|x| x.full()).collect(); if enum_.variants.iter().any(|x| attrs_skip(&x.attributes)) { @@ -1271,12 +1287,12 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { let to_add = enum_.generics.iter().filter(|x| { ty.wraps() .iter() - .any(|wrapped_type| &x.full() == wrapped_type) + .any(|wrapped_type| x.full() == wrapped_type) }); used_generics.extend(to_add); used_generics.extend(get_used_lifetimes(ty).into_iter().filter_map(|x| { - match struct_generics_names_hash.contains(&x) { + match struct_generics_names_hash.contains(x.as_str()) { true => Some( enum_ .generics @@ -1402,7 +1418,9 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { let start = "\n#[serde(bound = \""; let mid = used_generics .iter() - .filter(|gen| !matches!(gen, Generic::Lifetime { .. } | Generic::Const { .. })) + .filter(|gen_type| { + !matches!(gen_type, Generic::Lifetime { .. } | Generic::Const { .. }) + }) .map(|x| { format!( "{}: serde::Serialize + serde::de::DeserializeOwned", @@ -1511,7 +1529,7 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_with_const) .collect::>() .join(", ") @@ -1522,7 +1540,7 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_with_const)) .collect::>() .join(", ") @@ -1532,12 +1550,12 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, false, true)) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds(), &[], true)) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds(), &[], true)) .collect::>() .join(",\n") ), @@ -1546,12 +1564,12 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, true, true)) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds_ref(), &["\'__diff_target"], true)) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds_ref(), &["\'__diff_target"], true)) .chain(std::iter::once(String::from("Self: '__diff_target"))) .collect::>() .join(",\n") @@ -1561,12 +1579,12 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, true, true)) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds_ref(), &["\'__diff_target"], true)) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds_ref(), &["\'__diff_target"], true)) .collect::>() .join(",\n") ), @@ -1575,12 +1593,12 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!( - gen, + .filter(|gen_type| !matches!( + gen_type, Generic::WhereBounded { .. } | Generic::Const { .. } )) .filter(|g| Generic::has_where_bounds(g, true, true)) - .map(|gen| Generic::full_with_const(gen, &[], &["\'__diff_target"], true)) + .map(|gen_type| Generic::full_with_const(gen_type, &[], &["\'__diff_target"], true)) .collect::>() .join(",\n") ), @@ -1589,7 +1607,7 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_with_const) .collect::>() .join(", ") @@ -1599,7 +1617,7 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_only) .collect::>() .join(", ") @@ -1609,13 +1627,13 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::Const { .. } | Generic::WhereBounded { .. })) - .map(|gen| Generic::full_with_const(gen, get_used_generic_bounds(), &[],true)) + .filter(|gen_type| !matches!(gen_type, Generic::Const { .. } | Generic::WhereBounded { .. })) + .map(|gen_type| Generic::full_with_const(gen_type, get_used_generic_bounds(), &[],true)) .collect::>().into_iter().chain(enum_ .generics .iter() - .filter(|gen| matches!(gen, Generic::WhereBounded { .. })) - .map(|gen| Generic::full_with_const(gen, &[], &[], true)).collect::>().into_iter()).collect::>() + .filter(|gen_type| matches!(gen_type, Generic::WhereBounded { .. })) + .map(|gen_type| Generic::full_with_const(gen_type, &[], &[], true)).collect::>().into_iter()).collect::>() .join(",\n") ), enum_impl_generics = format_args!( @@ -1623,7 +1641,7 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_only) .collect::>() .join(", ") @@ -1634,7 +1652,7 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream { enum_ .generics .iter() - .filter(|gen| !matches!(gen, Generic::WhereBounded { .. })) + .filter(|gen_type| !matches!(gen_type, Generic::WhereBounded { .. })) .map(Generic::ident_only)) .collect::>() .join(", ") diff --git a/derive/src/parse.rs b/derive/src/parse.rs index 8272759..11ac462 100644 --- a/derive/src/parse.rs +++ b/derive/src/parse.rs @@ -173,23 +173,23 @@ impl Data { } impl Generic { - pub fn full(&self) -> String { + pub fn full(&self) -> &str { match &self { - Generic::Const { name, .. } => name.clone(), - Generic::Regular { name, .. } => name.clone(), - Generic::Lifetime { name, .. } => name.clone(), - Generic::WhereBounded { name, .. } => name.clone(), + Generic::Const { name, .. } => name, + Generic::Regular { name, .. } => name, + Generic::Lifetime { name, .. } => name, + Generic::WhereBounded { name, .. } => name, } } - fn lifetime_prefix(&self) -> &str { + fn lifetime_prefix(&self) -> &'static str { match &self { Generic::Lifetime { .. } => "\'", _ => "", } } - fn const_prefix(&self) -> &str { + fn const_prefix(&self) -> &'static str { match &self { Generic::Const { .. } => "const ", _ => "", @@ -1421,7 +1421,7 @@ fn get_all_bounds + Clone>(source: &mut Peekable + Clone>(source: &mut Peekable + Clone>(source: &mut Peekable Generic::WhereBounded { name, bounds }, where_bounded @ Generic::WhereBounded { .. } => where_bounded, diff --git a/derive/src/shared.rs b/derive/src/shared.rs index 43fb6f4..daf2242 100644 --- a/derive/src/shared.rs +++ b/derive/src/shared.rs @@ -23,7 +23,7 @@ pub enum CollectionStrategy { } #[cfg(feature = "generated_setters")] -pub fn attrs_setter(attributes: &[crate::parse::Attribute]) -> (bool, bool, Option) { +pub fn attrs_setter(attributes: &[crate::parse::Attribute]) -> (bool, bool, Option<&str>) { let skip = attributes .iter() .any(|attr| attr.tokens.len() == 1 && attr.tokens[0] == "skip_setter"); @@ -33,7 +33,7 @@ pub fn attrs_setter(attributes: &[crate::parse::Attribute]) -> (bool, bool, Opti let Some(name_override) = attributes.iter().find_map(|attr| { if attr.tokens.len() == 2 && attr.tokens[0] == "setter_name" { - Some(attr.tokens[1].clone()) + Some(&attr.tokens[1]) } else { None } @@ -87,7 +87,7 @@ pub fn attrs_collection_type(attributes: &[crate::parse::Attribute]) -> Option Option { attributes.iter().find_map(|attr| { if attr.tokens.len() == 2 && attr.tokens[0] == "map_equality" { - let strategy = match attr.tokens[1].clone().as_str() { + let strategy = match attr.tokens[1].as_str() { "key_only" => MapStrategy::KeyOnly, "key_and_value" => MapStrategy::KeyAndValue, _ => { @@ -101,10 +101,10 @@ pub fn attrs_map_strategy(attributes: &[crate::parse::Attribute]) -> Option Option> { +pub fn attrs_expose(attributes: &[crate::parse::Attribute]) -> Option> { attributes.iter().find_map(|attr| match attr.tokens.len() { 1 if attr.tokens[0].starts_with("expose") => Some(None), - 2.. if attr.tokens[0] == "expose" => Some(Some(attr.tokens[1].to_string())), + 2.. if attr.tokens[0] == "expose" => Some(Some(attr.tokens[1].as_str())), _ => None, }) } diff --git a/justfile b/justfile new file mode 100644 index 0000000..e412fc5 --- /dev/null +++ b/justfile @@ -0,0 +1,6 @@ +fmt: + cargo fmt && cargo fmt --manifest-path ./derive/Cargo.toml +clippy: + cargo clippy --all-features && cargo clippy --all-features --manifest-path ./derive/Cargo.toml +test: + cargo test && cargo test --all-features diff --git a/src/collections/ordered_array_like.rs b/src/collections/ordered_array_like.rs index 72effb2..668455b 100644 --- a/src/collections/ordered_array_like.rs +++ b/src/collections/ordered_array_like.rs @@ -174,6 +174,7 @@ fn create_full_change_table( entry[0] = ChangeInternal::Insert(i * INSERT_COST); } + #[allow(clippy::needless_range_loop)] for j in 0..=source.len() { table[0][j] = ChangeInternal::Delete(j * DELETE_COST) } diff --git a/tests/derives.rs b/tests/derives.rs index 2c684e6..746ba80 100644 --- a/tests/derives.rs +++ b/tests/derives.rs @@ -30,7 +30,7 @@ pub struct TestDeriveAll< [i32; N]: Default, [B; N]: Default, dyn Fn(&B): PartialEq + Clone + core::fmt::Debug, - (dyn core::fmt::Debug + Send + 'static): Debug, + dyn core::fmt::Debug + Send + 'static: Debug, { f1: (), f2: [A; N], diff --git a/tests/enums.rs b/tests/enums.rs index 27ea4ec..525ef44 100644 --- a/tests/enums.rs +++ b/tests/enums.rs @@ -6,8 +6,9 @@ use std::{ fmt::Debug, num::Wrapping, }; -use structdiff::{Difference, StructDiff}; +use structdiff::Difference; +#[allow(dead_code)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[derive(Debug, PartialEq, Clone, Difference, Default)] #[difference(setters)] @@ -19,6 +20,7 @@ pub struct Test { pub test5: Option, } +#[allow(dead_code)] #[derive(Debug, PartialEq, Clone, Difference)] #[difference(setters)] pub struct TestSkip diff --git a/tests/types.rs b/tests/types.rs index 2b8f676..58e695c 100644 --- a/tests/types.rs +++ b/tests/types.rs @@ -6,6 +6,7 @@ use nanorand::{Rng, WyRand}; use nanoserde::{DeBin, SerBin}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; +#[cfg_attr(not(feature = "generated_setters"), expect(unused_imports))] use structdiff::{Difference, StructDiff}; pub trait RandValue @@ -96,6 +97,7 @@ impl RandValue for TestEnum { #[derive(Difference, Default, PartialEq, Debug, Clone)] #[difference(setters)] +#[allow(unused)] pub struct TestSetters { #[difference(setter_name = "testing123", recurse)] pub f0: Test,