Parametrize needs_bounds_derive and collect_bounds with IS_ASYNC

Author: DanikVitek

borsh-derive/src/internals/attributes/field/mod.rs

@@ -221,39 +221,21 @@ impl Attributes {
         Ok(result)
     }
 
-    pub(crate) fn needs_bounds_derive(&self, ty: BoundType) -> bool {
-        let predicates = self.get_bounds(ty);
+    pub(crate) fn needs_bounds_derive<const IS_ASYNC: bool>(&self, ty: BoundType) -> bool {
+        let predicates = self.get_bounds::<IS_ASYNC>(ty);
         predicates.is_none()
     }
 
-    pub(crate) fn needs_async_bounds_derive(&self, ty: BoundType) -> bool {
-        let predicates = self.get_async_bounds(ty);
-        predicates.is_none()
-    }
-
-    fn get_bounds(&self, ty: BoundType) -> Option<Vec<WherePredicate>> {
-        let bounds = self.bounds.as_ref();
-        bounds.and_then(|bounds| match ty {
-            BoundType::Serialize => bounds.serialize.clone(),
-            BoundType::Deserialize => bounds.deserialize.clone(),
-        })
-    }
-
-    fn get_async_bounds(&self, ty: BoundType) -> Option<Vec<WherePredicate>> {
-        let bounds = self.async_bounds.as_ref();
+    fn get_bounds<const IS_ASYNC: bool>(&self, ty: BoundType) -> Option<Vec<WherePredicate>> {
+        let bounds = if IS_ASYNC { self.async_bounds.as_ref() } else { self.bounds.as_ref() };
         bounds.and_then(|bounds| match ty {
             BoundType::Serialize => bounds.serialize.clone(),
             BoundType::Deserialize => bounds.deserialize.clone(),
         })
     }
 
-    pub(crate) fn collect_bounds(&self, ty: BoundType) -> Vec<WherePredicate> {
-        let predicates = self.get_bounds(ty);
-        predicates.unwrap_or_default()
-    }
-
-    pub(crate) fn collect_async_bounds(&self, ty: BoundType) -> Vec<WherePredicate> {
-        let predicates = self.get_async_bounds(ty);
+    pub(crate) fn collect_bounds<const IS_ASYNC: bool>(&self, ty: BoundType) -> Vec<WherePredicate> {
+        let predicates = self.get_bounds::<IS_ASYNC>(ty);
         predicates.unwrap_or_default()
     }
 }

borsh-derive/src/internals/deserialize/mod.rs

@@ -51,16 +51,10 @@ fn process_field<const IS_ASYNC: bool>(
 ) -> syn::Result<()> {
     let parsed = field::Attributes::parse(&field.attrs)?;
 
-    generics.overrides.extend(if IS_ASYNC {
-        parsed.collect_async_bounds(BoundType::Deserialize)
-    } else {
-        parsed.collect_bounds(BoundType::Deserialize)
-    });
-    let needs_bounds_derive = if IS_ASYNC {
-        parsed.needs_async_bounds_derive(BoundType::Deserialize)
-    } else {
-        parsed.needs_bounds_derive(BoundType::Deserialize)
-    };
+    generics
+        .overrides
+        .extend(parsed.collect_bounds::<IS_ASYNC>(BoundType::Deserialize));
+    let needs_bounds_derive = parsed.needs_bounds_derive::<IS_ASYNC>(BoundType::Deserialize);
 
     let field_name = field.ident.as_ref();
     let delta = if parsed.skip {

borsh-derive/src/internals/serialize/enums/mod.rs

@@ -218,16 +218,10 @@ fn process_field<const IS_ASYNC: bool>(
 ) -> syn::Result<()> {
     let parsed = field::Attributes::parse(&field.attrs)?;
 
-    let needs_bounds_derive = if IS_ASYNC {
-        parsed.needs_async_bounds_derive(BoundType::Serialize)
-    } else {
-        parsed.needs_bounds_derive(BoundType::Serialize)
-    };
-    generics.overrides.extend(if IS_ASYNC {
-        parsed.collect_async_bounds(BoundType::Serialize)
-    } else {
-        parsed.collect_bounds(BoundType::Serialize)
-    });
+    let needs_bounds_derive = parsed.needs_bounds_derive::<IS_ASYNC>(BoundType::Serialize);
+    generics
+        .overrides
+        .extend(parsed.collect_bounds::<IS_ASYNC>(BoundType::Serialize));
 
     let field_variant_header = field_id.enum_variant_header(parsed.skip);
     if let Some(field_variant_header) = field_variant_header {

borsh-derive/src/internals/serialize/structs/mod.rs

@@ -87,16 +87,10 @@ fn process_field<const IS_ASYNC: bool>(
 ) -> syn::Result<()> {
     let parsed = field::Attributes::parse(&field.attrs)?;
 
-    let needs_bounds_derive = if IS_ASYNC {
-        parsed.needs_async_bounds_derive(BoundType::Serialize)
-    } else {
-        parsed.needs_bounds_derive(BoundType::Serialize)
-    };
-    generics.overrides.extend(if IS_ASYNC {
-        parsed.collect_async_bounds(BoundType::Serialize)
-    } else {
-        parsed.collect_bounds(BoundType::Serialize)
-    });
+    let needs_bounds_derive = parsed.needs_bounds_derive::<IS_ASYNC>(BoundType::Serialize);
+    generics
+        .overrides
+        .extend(parsed.collect_bounds::<IS_ASYNC>(BoundType::Serialize));
 
     if !parsed.skip {
         let delta = field_id.serialize_output::<IS_ASYNC>(