refactor: reduce use of clone

packages/fortifier-macros/src/lib.rs

@@ -17,7 +17,7 @@ use crate::validate::Validate;
 pub fn derive(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
 
-    Validate::parse(input)
+    Validate::parse(&input)
         .map(|validate| validate.to_token_stream())
         .unwrap_or_else(Error::into_compile_error)
         .into()

packages/fortifier-macros/src/validate.rs

@@ -11,23 +11,23 @@ use syn::{Data, DeriveInput, Result};
 
 use crate::validate::{r#enum::ValidateEnum, r#struct::ValidateStruct, union::ValidateUnion};
 
-pub enum Validate {
-    Struct(ValidateStruct),
-    Enum(ValidateEnum),
+pub enum Validate<'a> {
+    Struct(ValidateStruct<'a>),
+    Enum(ValidateEnum<'a>),
     Union(ValidateUnion),
 }
 
-impl Validate {
-    pub fn parse(input: DeriveInput) -> Result<Self> {
+impl<'a> Validate<'a> {
+    pub fn parse(input: &'a DeriveInput) -> Result<Self> {
         Ok(match &input.data {
-            Data::Struct(data) => Self::Struct(ValidateStruct::parse(&input, data)?),
-            Data::Enum(data) => Self::Enum(ValidateEnum::parse(&input, data)?),
-            Data::Union(data) => Self::Union(ValidateUnion::parse(&input, data)?),
+            Data::Struct(data) => Self::Struct(ValidateStruct::parse(input, data)?),
+            Data::Enum(data) => Self::Enum(ValidateEnum::parse(input, data)?),
+            Data::Union(data) => Self::Union(ValidateUnion::parse(input, data)?),
         })
     }
 }
 
-impl ToTokens for Validate {
+impl<'a> ToTokens for Validate<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         match self {
             Validate::Struct(r#struct) => r#struct.to_tokens(tokens),

packages/fortifier-macros/src/validate/enum.rs

@@ -11,37 +11,37 @@ use crate::{
     validation::Execution,
 };
 
-pub struct ValidateEnum {
-    visibility: Visibility,
-    ident: Ident,
+pub struct ValidateEnum<'a> {
+    visibility: &'a Visibility,
+    ident: &'a Ident,
     error_ident: Ident,
-    generics: Generics,
-    variants: Vec<ValidateEnumVariant>,
+    generics: &'a Generics,
+    variants: Vec<ValidateEnumVariant<'a>>,
 }
 
-impl ValidateEnum {
-    pub fn parse(input: &DeriveInput, data: &DataEnum) -> Result<Self> {
+impl<'a> ValidateEnum<'a> {
+    pub fn parse(input: &'a DeriveInput, data: &'a DataEnum) -> Result<Self> {
         let mut result = ValidateEnum {
-            visibility: input.vis.clone(),
-            ident: input.ident.clone(),
+            visibility: &input.vis,
+            ident: &input.ident,
             error_ident: format_ident!("{}ValidationError", input.ident),
-            generics: input.generics.clone(),
+            generics: &input.generics,
             variants: Vec::with_capacity(data.variants.len()),
         };
 
         for variant in &data.variants {
             result.variants.push(ValidateEnumVariant::parse(
                 &input.vis,
-                &result.ident,
-                &result.error_ident,
+                result.ident,
+                result.error_ident.clone(),
                 variant,
             )?);
         }
 
         Ok(result)
     }
 
-    fn error_type(&self) -> (Ident, TokenStream) {
+    fn error_type(&self) -> (&Ident, TokenStream) {
         let visibility = &self.visibility;
         let error_ident = &self.error_ident;
 
@@ -58,7 +58,7 @@ impl ValidateEnum {
             .collect::<Vec<_>>();
 
         (
-            error_ident.clone(),
+            error_ident,
             quote! {
                 #[allow(dead_code)]
                 #[derive(Debug)]
@@ -81,7 +81,7 @@ impl ValidateEnum {
     }
 }
 
-impl ToTokens for ValidateEnum {
+impl<'a> ToTokens for ValidateEnum<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let ident = &self.ident;
         let (impl_generics, type_generics, where_clause) = &self.generics.split_for_impl();
@@ -124,27 +124,27 @@ impl ToTokens for ValidateEnum {
     }
 }
 
-pub struct ValidateEnumVariant {
-    enum_ident: Ident,
+pub struct ValidateEnumVariant<'a> {
+    enum_ident: &'a Ident,
     enum_error_ident: Ident,
-    ident: Ident,
-    fields: ValidateFields,
+    ident: &'a Ident,
+    fields: ValidateFields<'a>,
 }
 
-impl ValidateEnumVariant {
+impl<'a> ValidateEnumVariant<'a> {
     pub fn parse(
-        visibility: &Visibility,
-        enum_ident: &Ident,
-        enum_error_ident: &Ident,
-        variant: &Variant,
+        visibility: &'a Visibility,
+        enum_ident: &'a Ident,
+        enum_error_ident: Ident,
+        variant: &'a Variant,
     ) -> Result<Self> {
         let result = ValidateEnumVariant {
-            enum_ident: enum_ident.clone(),
-            enum_error_ident: enum_error_ident.clone(),
-            ident: variant.ident.clone(),
+            enum_ident,
+            enum_error_ident,
+            ident: &variant.ident,
             fields: ValidateFields::parse(
                 visibility,
-                &format_ident!("{}{}", enum_ident, variant.ident),
+                format_ident!("{}{}", enum_ident, variant.ident),
                 &variant.fields,
             )?,
         };

packages/fortifier-macros/src/validate/field.rs

@@ -30,17 +30,17 @@ pub enum ValidateFieldPrefix {
     F,
 }
 
-pub struct ValidateField {
-    visibility: Visibility,
+pub struct ValidateField<'a> {
+    visibility: &'a Visibility,
     ident: LiteralOrIdent,
     error_ident: Ident,
     error_type_ident: Ident,
     validations: Vec<Box<dyn Validation>>,
 }
 
-impl ValidateField {
+impl<'a> ValidateField<'a> {
     pub fn parse(
-        visibility: &Visibility,
+        visibility: &'a Visibility,
         type_prefix: &Ident,
         ident: LiteralOrIdent,
         field: &Field,
@@ -54,7 +54,7 @@ impl ValidateField {
         let error_type_ident = format_ident!("{type_prefix}{error_ident}ValidationError");
 
         let mut result = Self {
-            visibility: visibility.clone(),
+            visibility,
             ident,
             error_ident,
             error_type_ident,

packages/fortifier-macros/src/validate/fields.rs

@@ -10,14 +10,14 @@ use crate::{
     validation::Execution,
 };
 
-pub enum ValidateFields {
-    Named(ValidateNamedFields),
-    Unnamed(ValidateUnnamedFields),
+pub enum ValidateFields<'a> {
+    Named(ValidateNamedFields<'a>),
+    Unnamed(ValidateUnnamedFields<'a>),
     Unit(ValidateUnitFields),
 }
 
-impl ValidateFields {
-    pub fn parse(visibility: &Visibility, ident: &Ident, fields: &Fields) -> Result<Self> {
+impl<'a> ValidateFields<'a> {
+    pub fn parse(visibility: &'a Visibility, ident: Ident, fields: &'a Fields) -> Result<Self> {
         Ok(match fields {
             Fields::Named(fields) => {
                 Self::Named(ValidateNamedFields::parse(visibility, ident, fields)?)
@@ -55,19 +55,21 @@ impl ValidateFields {
     }
 }
 
-pub struct ValidateNamedFields {
-    visibility: Visibility,
+pub struct ValidateNamedFields<'a> {
+    visibility: &'a Visibility,
     ident: Ident,
     error_ident: Ident,
-    fields: Vec<ValidateField>,
+    fields: Vec<ValidateField<'a>>,
 }
 
-impl ValidateNamedFields {
-    fn parse(visibility: &Visibility, ident: &Ident, fields: &FieldsNamed) -> Result<Self> {
+impl<'a> ValidateNamedFields<'a> {
+    fn parse(visibility: &'a Visibility, ident: Ident, fields: &'a FieldsNamed) -> Result<Self> {
+        let error_ident = format_ident!("{}ValidationError", ident);
+
         let mut result = Self {
-            visibility: visibility.clone(),
-            ident: ident.clone(),
-            error_ident: format_ident!("{}ValidationError", ident),
+            visibility,
+            ident,
+            error_ident,
             fields: Vec::with_capacity(fields.named.len()),
         };
 
@@ -78,7 +80,7 @@ impl ValidateNamedFields {
 
             result.fields.push(ValidateField::parse(
                 visibility,
-                ident,
+                &result.ident,
                 LiteralOrIdent::Ident(field_ident.clone()),
                 field,
             )?);
@@ -93,7 +95,7 @@ impl ValidateNamedFields {
 
     fn error_type(&self) -> (TokenStream, TokenStream) {
         error_type(
-            &self.visibility,
+            self.visibility,
             &self.ident,
             &self.error_ident,
             self.fields.iter(),
@@ -116,26 +118,28 @@ impl ValidateNamedFields {
     }
 }
 
-pub struct ValidateUnnamedFields {
-    visibility: Visibility,
+pub struct ValidateUnnamedFields<'a> {
+    visibility: &'a Visibility,
     ident: Ident,
     error_ident: Ident,
-    fields: Vec<ValidateField>,
+    fields: Vec<ValidateField<'a>>,
 }
 
-impl ValidateUnnamedFields {
-    fn parse(visibility: &Visibility, ident: &Ident, fields: &FieldsUnnamed) -> Result<Self> {
+impl<'a> ValidateUnnamedFields<'a> {
+    fn parse(visibility: &'a Visibility, ident: Ident, fields: &'a FieldsUnnamed) -> Result<Self> {
+        let error_ident = format_ident!("{}ValidationError", ident);
+
         let mut result = Self {
-            visibility: visibility.clone(),
-            ident: ident.clone(),
-            error_ident: format_ident!("{}ValidationError", ident),
+            visibility,
+            ident,
+            error_ident,
             fields: Vec::with_capacity(fields.unnamed.len()),
         };
 
         for (index, field) in fields.unnamed.iter().enumerate() {
             result.fields.push(ValidateField::parse(
                 visibility,
-                ident,
+                &result.ident,
                 LiteralOrIdent::Literal(Literal::usize_unsuffixed(index)),
                 field,
             )?);
@@ -150,7 +154,7 @@ impl ValidateUnnamedFields {
 
     fn error_type(&self) -> (TokenStream, TokenStream) {
         error_type(
-            &self.visibility,
+            self.visibility,
             &self.ident,
             &self.error_ident,
             self.fields.iter(),
@@ -195,7 +199,7 @@ fn error_type<'a>(
     visibility: &Visibility,
     ident: &Ident,
     error_ident: &Ident,
-    fields: impl Iterator<Item = &'a ValidateField>,
+    fields: impl Iterator<Item = &'a ValidateField<'a>>,
 ) -> (TokenStream, TokenStream) {
     let attributes = enum_attributes();
 
@@ -207,7 +211,7 @@ fn error_type<'a>(
         let field_error_ident = field.error_ident();
         let (field_error_type, field_error_enum) = field.error_type(ident);
 
-        error_field_idents.push(field_error_ident.clone());
+        error_field_idents.push(field_error_ident);
         error_field_types.push(field_error_type);
         if let Some(error_enum) = field_error_enum {
             error_field_enums.push(error_enum);
@@ -244,7 +248,7 @@ fn validations<'a>(
     field_prefix: ValidateFieldPrefix,
     error_ident: &Ident,
     error_wrapper: &impl Fn(TokenStream) -> TokenStream,
-    fields: impl Iterator<Item = &'a ValidateField>,
+    fields: impl Iterator<Item = &'a ValidateField<'a>>,
 ) -> TokenStream {
     let error_ident = &error_ident;
 

packages/fortifier-macros/src/validate/struct.rs

@@ -7,23 +7,23 @@ use crate::{
     validation::Execution,
 };
 
-pub struct ValidateStruct {
-    ident: Ident,
-    generics: Generics,
-    fields: ValidateFields,
+pub struct ValidateStruct<'a> {
+    ident: &'a Ident,
+    generics: &'a Generics,
+    fields: ValidateFields<'a>,
 }
 
-impl ValidateStruct {
-    pub fn parse(input: &DeriveInput, data: &DataStruct) -> Result<Self> {
+impl<'a> ValidateStruct<'a> {
+    pub fn parse(input: &'a DeriveInput, data: &'a DataStruct) -> Result<Self> {
         Ok(ValidateStruct {
-            ident: input.ident.clone(),
-            generics: input.generics.clone(),
-            fields: ValidateFields::parse(&input.vis, &input.ident, &data.fields)?,
+            ident: &input.ident,
+            generics: &input.generics,
+            fields: ValidateFields::parse(&input.vis, input.ident.clone(), &data.fields)?,
         })
     }
 }
 
-impl ToTokens for ValidateStruct {
+impl<'a> ToTokens for ValidateStruct<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let ident = &self.ident;
         let (impl_generics, type_generics, where_clause) = self.generics.split_for_impl();