Merge pull request #145 from greyblake/generics-trait-boundaries

WIP: Start working on trait boundaries for generics

Author: greyblake

README.md

@@ -376,12 +376,6 @@ assert_eq!(name.into_inner(), " boo ");
 * IDEs may not be very helpful at giving you hints about proc macros.
 * Design of nutype may enforce you to run unnecessary validation (e.g. on loading data from DB), which may have a negative impact if you aim for extreme performance.
 
-## A note about #[derive(...)]
-
-You've got to know that the `#[nutype]` macro intercepts `#[derive(...)]` macro.
-It's done on purpose to ensure that anything like `DerefMut` or `BorrowMut`, that can lead to a violation of the validation rules is excluded.
-The library takes a conservative approach and it has its downside: deriving traits that are not known to the library is not possible.
-
 ## Support Ukrainian military forces
 
 Today I live in Berlin, I have the luxury to live a physically safe life.

dummy/src/main.rs

@@ -1,10 +1,24 @@
 use nutype::nutype;
-use std::borrow::Cow;
+use std::cmp::Ord;
 
-#[nutype(derive(Into))]
-struct Clarabelle<'a>(Cow<'a, str>);
+#[nutype(
+    sanitize(with = |mut v| { v.sort(); v }),
+    validate(predicate = |vec| !vec.is_empty()),
+    derive(Debug, Deserialize, Serialize),
+)]
+struct SortedNotEmptyVec<T: Ord>(Vec<T>);
 
 fn main() {
-    // let clarabelle = Clarabelle::new(Cow::Borrowed("Clarabelle"));
-    // assert_eq!(clarabelle.to_string(), "Clarabelle");
+    {
+        // Not empty vec is fine
+        let json = "[3, 1, 5, 2]";
+        let sv = serde_json::from_str::<SortedNotEmptyVec<i32>>(json).unwrap();
+        assert_eq!(sv.into_inner(), vec![1, 2, 3, 5]);
+    }
+    {
+        // Empty vec is not allowed
+        let json = "[]";
+        let result = serde_json::from_str::<SortedNotEmptyVec<i32>>(json);
+        assert!(result.is_err());
+    }
 }

examples/any_generics/src/main.rs

@@ -1,12 +1,29 @@
 use nutype::nutype;
 use std::borrow::Cow;
+use std::cmp::Ord;
 
+/// A wrapper around a vector that is guaranteed to be sorted.
+#[nutype(
+    sanitize(with = |mut v| { v.sort(); v }),
+    derive(Debug, Deserialize, Serialize)
+)]
+struct SortedVec<T: Ord>(Vec<T>);
+
+/// A wrapper around a vector that is guaranteed to be non-empty.
 #[nutype(
     validate(predicate = |vec| !vec.is_empty()),
     derive(Debug),
 )]
 struct NotEmpty<T>(Vec<T>);
 
+#[nutype(
+    sanitize(with = |mut v| { v.sort(); v }),
+    validate(predicate = |vec| !vec.is_empty()),
+    derive(Debug, Deserialize, Serialize),
+)]
+struct SortedNotEmptyVec<T: Ord>(Vec<T>);
+
+/// An example with lifetimes
 #[nutype(derive(
     Debug,
     Display,
@@ -32,15 +49,50 @@ struct NotEmpty<T>(Vec<T>);
 struct Clarabelle<'a>(Cow<'a, str>);
 
 fn main() {
+    // SortedVec
+    //
     {
-        let v = NotEmpty::new(vec![1, 2, 3]).unwrap();
-        assert_eq!(v.into_inner(), vec![1, 2, 3]);
+        let v = SortedVec::new(vec![3, 0, 2]);
+        assert_eq!(v.into_inner(), vec![0, 2, 3]);
+    }
+    {
+        let sv = SortedVec::new(vec![4i32, 2, 8, 5]);
+        let json = serde_json::to_string(&sv).unwrap();
+        assert_eq!(json, "[2,4,5,8]");
     }
     {
+        let json = "[5,3,7]";
+        let sv = serde_json::from_str::<SortedVec<i32>>(json).unwrap();
+        assert_eq!(sv.into_inner(), vec![3, 5, 7]);
+    }
+
+    // NotEmpty
+    //
+    {
+        let v = NotEmpty::new(vec![1, 2, 3]).unwrap();
+        assert_eq!(v.into_inner(), vec![1, 2, 3]);
+
         let err = NotEmpty::<i32>::new(vec![]).unwrap_err();
         assert_eq!(err, NotEmptyError::PredicateViolated);
     }
 
+    // SortedNotEmptyVec
+    //
+    {
+        // Not empty vec is fine
+        let json = "[3, 1, 5, 2]";
+        let snev = serde_json::from_str::<SortedNotEmptyVec<i32>>(json).unwrap();
+        assert_eq!(snev.into_inner(), vec![1, 2, 3, 5]);
+    }
+    {
+        // Empty vec is not allowed
+        let json = "[]";
+        let result = serde_json::from_str::<SortedNotEmptyVec<i32>>(json);
+        assert!(result.is_err());
+    }
+
+    // Clarabelle (Cow)
+    //
     {
         let muu = Clarabelle::new(Cow::Borrowed("Muu"));
         assert_eq!(muu.to_string(), "Muu");

nutype_macros/src/common/gen/mod.rs

@@ -138,8 +138,9 @@ pub fn gen_impl_into_inner(
     generics: &Generics,
     inner_type: impl ToTokens,
 ) -> TokenStream {
+    let generics_without_bounds = strip_trait_bounds_on_generics(generics);
     quote! {
-        impl #generics #type_name #generics {
+        impl #generics #type_name #generics_without_bounds {
             #[inline]
             pub fn into_inner(self) -> #inner_type {
                 self.0
@@ -148,6 +149,43 @@ pub fn gen_impl_into_inner(
     }
 }
 
+/// Remove trait bounds from generics.
+///
+/// Input:
+///    <T: Display + Debug, U: Clone>
+///
+/// Output:
+///   <T, U>
+fn strip_trait_bounds_on_generics(original: &Generics) -> Generics {
+    let mut generics = original.clone();
+    for param in &mut generics.params {
+        if let syn::GenericParam::Type(syn::TypeParam { bounds, .. }) = param {
+            *bounds = syn::punctuated::Punctuated::new();
+        }
+    }
+    generics
+}
+
+/// Add a bound to all generics types.
+///
+/// Input:
+///     <T, U>
+///     Serialize
+///
+/// Output:
+///    <T: Serialize, U: Serialize>
+fn add_bound_to_all_type_params(generics: &Generics, bound: TokenStream) -> Generics {
+    let mut generics = generics.clone();
+    let parsed_bound: syn::TypeParamBound =
+        syn::parse2(bound).expect("Failed to parse TypeParamBound");
+    for param in &mut generics.params {
+        if let syn::GenericParam::Type(syn::TypeParam { bounds, .. }) = param {
+            bounds.push(parsed_bound.clone());
+        }
+    }
+    generics
+}
+
 pub trait GenerateNewtype {
     type Sanitizer;
     type Validator;
@@ -197,6 +235,7 @@ pub trait GenerateNewtype {
         sanitizers: &[Self::Sanitizer],
         validators: &[Self::Validator],
     ) -> TokenStream {
+        let generics_without_bounds = strip_trait_bounds_on_generics(generics);
         let fn_sanitize = Self::gen_fn_sanitize(inner_type, sanitizers);
         let validation_error = Self::gen_validation_error_type(type_name, validators);
         let error_type_name = gen_error_type_name(type_name);
@@ -214,7 +253,7 @@ pub trait GenerateNewtype {
         quote!(
             #validation_error
 
-            impl #generics #type_name #generics {
+            impl #generics #type_name #generics_without_bounds {
                 pub fn new(raw_value: #input_type) -> ::core::result::Result<Self, #error_type_name> {
                     #convert_raw_value_if_necessary
 
@@ -237,6 +276,7 @@ pub trait GenerateNewtype {
         inner_type: &Self::InnerType,
         sanitizers: &[Self::Sanitizer],
     ) -> TokenStream {
+        let generics_without_bounds = strip_trait_bounds_on_generics(generics);
         let fn_sanitize = Self::gen_fn_sanitize(inner_type, sanitizers);
 
         let (input_type, convert_raw_value_if_necessary) = if Self::NEW_CONVERT_INTO_INNER_TYPE {
@@ -249,7 +289,7 @@ pub trait GenerateNewtype {
         };
 
         quote!(
-            impl #generics #type_name #generics {
+            impl #generics #type_name #generics_without_bounds {
                 pub fn new(raw_value: #input_type) -> Self {
                     #convert_raw_value_if_necessary
                     Self(Self::__sanitize__(raw_value))

nutype_macros/src/common/gen/traits.rs

@@ -4,7 +4,10 @@ use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 use syn::Generics;
 
-use crate::common::models::{ErrorTypeName, InnerType, TypeName};
+use crate::common::{
+    gen::{add_bound_to_all_type_params, strip_trait_bounds_on_generics},
+    models::{ErrorTypeName, InnerType, TypeName},
+};
 
 use super::parse_error::{gen_def_parse_error, gen_parse_error_name};
 
@@ -106,8 +109,11 @@ pub fn gen_impl_trait_deref(
 }
 
 pub fn gen_impl_trait_display(type_name: &TypeName, generics: &Generics) -> TokenStream {
+    let generics_without_bounds = strip_trait_bounds_on_generics(generics);
+    let generics_with_display_bound =
+        add_bound_to_all_type_params(generics, syn::parse_quote!(::core::fmt::Display));
     quote! {
-        impl #generics ::core::fmt::Display for #type_name #generics {
+        impl #generics_with_display_bound ::core::fmt::Display for #type_name #generics_without_bounds {
             #[inline]
             fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 // A tiny wrapper function with trait boundary that improves error reporting.
@@ -239,9 +245,15 @@ pub fn gen_impl_trait_from_str(
 }
 
 pub fn gen_impl_trait_serde_serialize(type_name: &TypeName, generics: &Generics) -> TokenStream {
+    let generics_without_bounds = strip_trait_bounds_on_generics(generics);
+
+    // Turn `<T>` into `<T: Serialize>`
+    let all_generics_with_serialize_bound =
+        add_bound_to_all_type_params(generics, syn::parse_quote!(::serde::Serialize));
+
     let type_name_str = type_name.to_string();
     quote! {
-        impl #generics ::serde::Serialize for #type_name #generics {
+        impl #all_generics_with_serialize_bound ::serde::Serialize for #type_name #generics_without_bounds {
             fn serialize<S>(&self, serializer: S) -> ::core::result::Result<S::Ok, S::Error>
             where
                 S: ::serde::Serializer
@@ -283,17 +295,23 @@ pub fn gen_impl_trait_serde_deserialize(
         all_generics.params.push(syn::parse_quote!('de));
         all_generics
     };
+    let all_generics_without_bounds = strip_trait_bounds_on_generics(&all_generics);
+    let type_generics_without_bounds = strip_trait_bounds_on_generics(type_generics);
+
+    // Turn `<'de, T>` into `<'de, T: Deserialize<'de>>`
+    let all_generics_with_deserialize_bound =
+        add_bound_to_all_type_params(&all_generics, syn::parse_quote!(::serde::Deserialize<'de>));
 
     quote! {
-        impl #all_generics ::serde::Deserialize<'de> for #type_name #type_generics {
+        impl #all_generics_with_deserialize_bound ::serde::Deserialize<'de> for #type_name #type_generics_without_bounds {
             fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> ::core::result::Result<Self, D::Error> {
                 struct __Visitor #all_generics {
-                    marker: ::std::marker::PhantomData<#type_name #type_generics>,
+                    marker: ::std::marker::PhantomData<#type_name #type_generics_without_bounds>,
                     lifetime: ::std::marker::PhantomData<&'de ()>,
                 }
 
-                impl #all_generics ::serde::de::Visitor<'de> for __Visitor #all_generics {
-                    type Value = #type_name #type_generics;
+                impl #all_generics_with_deserialize_bound ::serde::de::Visitor<'de> for __Visitor #all_generics_without_bounds {
+                    type Value = #type_name #type_generics_without_bounds;
 
                     fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                         write!(formatter, #expecting_str)