feat: improve type heuristics by adding generics and more built-in types (#44)

Author: DanielleHuisman

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

@@ -1,6 +1,6 @@
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
-use syn::{DataEnum, DeriveInput, Ident, Result, Variant, Visibility};
+use syn::{DataEnum, DeriveInput, Generics, Ident, Result, Variant, Visibility};
 
 use crate::{
     validate::{
@@ -30,6 +30,7 @@ impl<'a> ValidateEnum<'a> {
         for variant in &data.variants {
             result.variants.push(ValidateEnumVariant::parse(
                 &input.vis,
+                &input.generics,
                 result.ident,
                 result.error_ident.clone(),
                 variant,
@@ -109,6 +110,7 @@ pub struct ValidateEnumVariant<'a> {
 impl<'a> ValidateEnumVariant<'a> {
     pub fn parse(
         visibility: &'a Visibility,
+        generics: &'a Generics,
         enum_ident: &'a Ident,
         enum_error_ident: Ident,
         variant: &'a Variant,
@@ -119,6 +121,7 @@ impl<'a> ValidateEnumVariant<'a> {
             ident: &variant.ident,
             fields: ValidateFields::parse(
                 visibility,
+                generics,
                 format_ident!("{}{}", enum_ident, variant.ident),
                 &variant.fields,
             )?,

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

@@ -1,7 +1,7 @@
 use convert_case::{Case, Casing};
 use proc_macro2::{Literal, TokenStream};
 use quote::{ToTokens, format_ident, quote};
-use syn::{Error, Field, Ident, Result, Visibility};
+use syn::{Error, Field, Generics, Ident, Result, Visibility};
 
 use crate::{
     validate::{
@@ -46,6 +46,7 @@ pub struct ValidateField<'a> {
 impl<'a> ValidateField<'a> {
     pub fn parse(
         visibility: &'a Visibility,
+        generics: &'a Generics,
         type_prefix: &Ident,
         ident: LiteralOrIdent,
         field: &Field,
@@ -128,10 +129,9 @@ impl<'a> ValidateField<'a> {
             }
         }
 
-        // TODO: Use enum/struct generics to determine if a generic field type supports nested validation.
         if !skip_nested
             && result.validations.is_empty()
-            && let Some(nested_type) = should_validate_type(&field.ty)
+            && let Some(nested_type) = should_validate_type(generics, &field.ty)
         {
             if let KnownOrUnknown::Known(nested_type) = nested_type {
                 result.validations.push(Box::new(Nested::new(nested_type)));

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

@@ -2,7 +2,7 @@ use std::iter::empty;
 
 use proc_macro2::{Literal, TokenStream};
 use quote::quote;
-use syn::{Fields, FieldsNamed, FieldsUnnamed, Ident, Result, Visibility};
+use syn::{Fields, FieldsNamed, FieldsUnnamed, Generics, Ident, Result, Visibility};
 
 use crate::{
     validate::{
@@ -22,14 +22,19 @@ pub enum ValidateFields<'a> {
 }
 
 impl<'a> ValidateFields<'a> {
-    pub fn parse(visibility: &'a Visibility, ident: Ident, fields: &'a Fields) -> Result<Self> {
+    pub fn parse(
+        visibility: &'a Visibility,
+        generics: &'a Generics,
+        ident: Ident,
+        fields: &'a Fields,
+    ) -> Result<Self> {
         Ok(match fields {
-            Fields::Named(fields) => {
-                Self::Named(ValidateNamedFields::parse(visibility, ident, fields)?)
-            }
-            Fields::Unnamed(fields) => {
-                Self::Unnamed(ValidateUnnamedFields::parse(visibility, ident, fields)?)
-            }
+            Fields::Named(fields) => Self::Named(ValidateNamedFields::parse(
+                visibility, generics, ident, fields,
+            )?),
+            Fields::Unnamed(fields) => Self::Unnamed(ValidateUnnamedFields::parse(
+                visibility, generics, ident, fields,
+            )?),
             Fields::Unit => Self::Unit(ValidateUnitFields::parse(visibility, ident)?),
         })
     }
@@ -94,7 +99,12 @@ pub struct ValidateNamedFields<'a> {
 }
 
 impl<'a> ValidateNamedFields<'a> {
-    fn parse(visibility: &'a Visibility, ident: Ident, fields: &'a FieldsNamed) -> Result<Self> {
+    fn parse(
+        visibility: &'a Visibility,
+        generics: &'a Generics,
+        ident: Ident,
+        fields: &'a FieldsNamed,
+    ) -> Result<Self> {
         let error_ident = format_error_ident(&ident);
 
         let mut result = Self {
@@ -111,6 +121,7 @@ impl<'a> ValidateNamedFields<'a> {
 
             result.fields.push(ValidateField::parse(
                 visibility,
+                generics,
                 &result.ident,
                 LiteralOrIdent::Ident(field_ident.clone()),
                 field,
@@ -173,7 +184,12 @@ pub struct ValidateUnnamedFields<'a> {
 }
 
 impl<'a> ValidateUnnamedFields<'a> {
-    fn parse(visibility: &'a Visibility, ident: Ident, fields: &'a FieldsUnnamed) -> Result<Self> {
+    fn parse(
+        visibility: &'a Visibility,
+        generics: &'a Generics,
+        ident: Ident,
+        fields: &'a FieldsUnnamed,
+    ) -> Result<Self> {
         let error_ident = format_error_ident(&ident);
 
         let mut result = Self {
@@ -186,6 +202,7 @@ impl<'a> ValidateUnnamedFields<'a> {
         for (index, field) in fields.unnamed.iter().enumerate() {
             result.fields.push(ValidateField::parse(
                 visibility,
+                generics,
                 &result.ident,
                 LiteralOrIdent::Literal(Literal::usize_unsuffixed(index)),
                 field,

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

@@ -13,7 +13,12 @@ pub struct ValidateStruct<'a> {
 impl<'a> ValidateStruct<'a> {
     pub fn parse(input: &'a DeriveInput, data: &'a DataStruct) -> Result<Self> {
         Ok(ValidateStruct {
-            fields: ValidateFields::parse(&input.vis, input.ident.clone(), &data.fields)?,
+            fields: ValidateFields::parse(
+                &input.vis,
+                &input.generics,
+                input.ident.clone(),
+                &data.fields,
+            )?,
         })
     }