Make it possible to derive From for Cow inner type

greyblake · Jun 1, 2024 · 2a044ed · 2a044ed
1 parent ba09d52
commit 2a044ed
Show file tree

Hide file tree

Showing 10 changed files with 56 additions and 17 deletions.
diff --git a/dummy/src/main.rs b/dummy/src/main.rs
@@ -1,10 +1,10 @@
 use nutype::nutype;
 use std::borrow::Cow;
 
-#[nutype(derive(Debug, Display))]
+#[nutype(derive(Into))]
 struct Clarabelle<'a>(Cow<'a, str>);
 
 fn main() {
-    let clarabelle = Clarabelle::new(Cow::Borrowed("Clarabelle"));
-    assert_eq!(clarabelle.to_string(), "Clarabelle");
+    // let clarabelle = Clarabelle::new(Cow::Borrowed("Clarabelle"));
+    // assert_eq!(clarabelle.to_string(), "Clarabelle");
 }
diff --git a/examples/any_generics/src/main.rs b/examples/any_generics/src/main.rs
@@ -7,7 +7,32 @@ use std::borrow::Cow;
 )]
 struct NotEmpty<T>(Vec<T>);
 
-#[nutype(derive(Debug, Display))]
+#[nutype(derive(
+    Debug,
+    Display,
+    Clone,
+    // Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+
+    // TODO
+    // AsRef,
+
+    Into,
+    From,
+    // Deref,
+    // Borrow,
+    // FromStr,
+    // TryFrom,
+    // Default,
+
+    // SerdeSerialize,
+    // SerdeDeserialize,
+    // ArbitraryArbitrary,
+))]
 struct Clarabelle<'b>(Cow<'b, str>);
 
 fn main() {

diff --git a/nutype_macros/src/any/gen/traits/mod.rs b/nutype_macros/src/any/gen/traits/mod.rs
@@ -154,7 +154,7 @@ fn gen_implemented_traits(
         .iter()
         .map(|t| match t {
             AnyIrregularTrait::AsRef => Ok(gen_impl_trait_as_ref(type_name, inner_type)),
-            AnyIrregularTrait::From => Ok(gen_impl_trait_from(type_name, inner_type)),
+            AnyIrregularTrait::From => Ok(gen_impl_trait_from(type_name, generics, inner_type)),
             AnyIrregularTrait::Into => Ok(gen_impl_trait_into(type_name, generics, inner_type.clone())),
             AnyIrregularTrait::Display => Ok(gen_impl_trait_display(type_name, generics)),
             AnyIrregularTrait::Deref => Ok(gen_impl_trait_deref(type_name, inner_type)),

diff --git a/nutype_macros/src/common/gen/traits.rs b/nutype_macros/src/common/gen/traits.rs
@@ -127,9 +127,13 @@ pub fn gen_impl_trait_borrow(type_name: &TypeName, borrowed_type: impl ToTokens)
     }
 }
 
-pub fn gen_impl_trait_from(type_name: &TypeName, inner_type: impl ToTokens) -> TokenStream {
+pub fn gen_impl_trait_from(
+    type_name: &TypeName,
+    generics: &Generics,
+    inner_type: impl ToTokens
+) -> TokenStream {
     quote! {
-        impl ::core::convert::From<#inner_type> for #type_name {
+        impl #generics ::core::convert::From<#inner_type> for #type_name #generics {
             #[inline]
             fn from(raw_value: #inner_type) -> Self {
                 Self::new(raw_value)

diff --git a/nutype_macros/src/float/gen/mod.rs b/nutype_macros/src/float/gen/mod.rs
@@ -137,7 +137,7 @@ where
 
     fn gen_traits(
         type_name: &TypeName,
-        _generics: &Generics,
+        generics: &Generics,
         inner_type: &Self::InnerType,
         maybe_error_type_name: Option<ErrorTypeName>,
         traits: HashSet<Self::TypedTrait>,
@@ -146,6 +146,7 @@ where
     ) -> Result<GeneratedTraits, syn::Error> {
         gen_traits(
             type_name,
+            generics,
             inner_type,
             maybe_error_type_name,
             maybe_default_value,

diff --git a/nutype_macros/src/float/gen/traits/mod.rs b/nutype_macros/src/float/gen/traits/mod.rs
@@ -123,6 +123,7 @@ impl ToTokens for FloatTransparentTrait {
 
 pub fn gen_traits<T: ToTokens>(
     type_name: &TypeName,
+    generics: &Generics,
     inner_type: &FloatInnerType,
     maybe_error_type_name: Option<ErrorTypeName>,
     maybe_default_value: Option<syn::Expr>,
@@ -142,6 +143,7 @@ pub fn gen_traits<T: ToTokens>(
 
     let implement_traits = gen_implemented_traits(
         type_name,
+        generics,
         inner_type,
         maybe_error_type_name,
         maybe_default_value,
@@ -157,6 +159,7 @@ pub fn gen_traits<T: ToTokens>(
 
 fn gen_implemented_traits<T: ToTokens>(
     type_name: &TypeName,
+    generics: &Generics,
     inner_type: &FloatInnerType,
     maybe_error_type_name: Option<ErrorTypeName>,
     maybe_default_value: Option<syn::Expr>,
@@ -171,13 +174,13 @@ fn gen_implemented_traits<T: ToTokens>(
             FloatIrregularTrait::FromStr => {
                 Ok(gen_impl_trait_from_str(type_name, inner_type, maybe_error_type_name.as_ref()))
             }
-            FloatIrregularTrait::From => Ok(gen_impl_trait_from(type_name, inner_type)),
-            FloatIrregularTrait::Into => Ok(gen_impl_trait_into(type_name, &Generics::default(), inner_type)),
+            FloatIrregularTrait::From => Ok(gen_impl_trait_from(type_name, generics, inner_type)),
+            FloatIrregularTrait::Into => Ok(gen_impl_trait_into(type_name, generics, inner_type)),
             FloatIrregularTrait::TryFrom => {
                 Ok(gen_impl_trait_try_from(type_name, inner_type, maybe_error_type_name.as_ref()))
             }
             FloatIrregularTrait::Borrow => Ok(gen_impl_trait_borrow(type_name, inner_type)),
-            FloatIrregularTrait::Display => Ok(gen_impl_trait_display(type_name, &Generics::default())),
+            FloatIrregularTrait::Display => Ok(gen_impl_trait_display(type_name, generics)),
             FloatIrregularTrait::Default => match maybe_default_value {
                 Some(ref default_value) => {
                     let has_validation = maybe_error_type_name.is_some();

diff --git a/nutype_macros/src/integer/gen/mod.rs b/nutype_macros/src/integer/gen/mod.rs
@@ -129,7 +129,7 @@ where
 
     fn gen_traits(
         type_name: &TypeName,
-        _generics: &Generics,
+        generics: &Generics,
         inner_type: &Self::InnerType,
         maybe_error_type_name: Option<ErrorTypeName>,
         traits: HashSet<Self::TypedTrait>,
@@ -138,6 +138,7 @@ where
     ) -> Result<GeneratedTraits, syn::Error> {
         gen_traits(
             type_name,
+            generics,
             inner_type,
             maybe_error_type_name,
             traits,

diff --git a/nutype_macros/src/integer/gen/traits/mod.rs b/nutype_macros/src/integer/gen/traits/mod.rs
@@ -24,6 +24,7 @@ type IntegerGeneratableTrait = GeneratableTrait<IntegerTransparentTrait, Integer
 
 pub fn gen_traits<T: ToTokens>(
     type_name: &TypeName,
+    generics: &Generics,
     inner_type: &IntegerInnerType,
     maybe_error_type_name: Option<ErrorTypeName>,
     traits: HashSet<IntegerDeriveTrait>,
@@ -43,6 +44,7 @@ pub fn gen_traits<T: ToTokens>(
 
     let implement_traits = gen_implemented_traits(
         type_name,
+        generics,
         inner_type,
         maybe_error_type_name,
         irregular_traits,
@@ -177,6 +179,7 @@ impl ToTokens for IntegerTransparentTrait {
 
 fn gen_implemented_traits<T: ToTokens>(
     type_name: &TypeName,
+    generics: &Generics,
     inner_type: &IntegerInnerType,
     maybe_error_type_name: Option<ErrorTypeName>,
     impl_traits: Vec<IntegerIrregularTrait>,
@@ -191,13 +194,13 @@ fn gen_implemented_traits<T: ToTokens>(
             IntegerIrregularTrait::FromStr => {
                 Ok(gen_impl_trait_from_str(type_name, inner_type, maybe_error_type_name.as_ref()))
             }
-            IntegerIrregularTrait::From => Ok(gen_impl_trait_from(type_name, inner_type)),
-            IntegerIrregularTrait::Into => Ok(gen_impl_trait_into(type_name, &Generics::default(), inner_type)),
+            IntegerIrregularTrait::From => Ok(gen_impl_trait_from(type_name, generics, inner_type)),
+            IntegerIrregularTrait::Into => Ok(gen_impl_trait_into(type_name, generics, inner_type)),
             IntegerIrregularTrait::TryFrom => {
                 Ok(gen_impl_trait_try_from(type_name, inner_type, maybe_error_type_name.as_ref()))
             }
             IntegerIrregularTrait::Borrow => Ok(gen_impl_trait_borrow(type_name, inner_type)),
-            IntegerIrregularTrait::Display => Ok(gen_impl_trait_display(type_name, &Generics::default())),
+            IntegerIrregularTrait::Display => Ok(gen_impl_trait_display(type_name, generics)),
             IntegerIrregularTrait::Default => {
                 match maybe_default_value {
                     Some(ref default_value) => {

diff --git a/nutype_macros/src/string/gen/traits/mod.rs b/nutype_macros/src/string/gen/traits/mod.rs
@@ -250,8 +250,9 @@ fn gen_impl_from_str(
 }
 
 fn gen_impl_from_str_and_string(type_name: &TypeName) -> TokenStream {
-    let impl_from_string = gen_impl_trait_from(type_name, quote!(String));
-    let impl_from_str = gen_impl_trait_from(type_name, quote!(&str));
+    let generics = Generics::default();
+    let impl_from_string = gen_impl_trait_from(type_name, &generics, quote!(String));
+    let impl_from_str = gen_impl_trait_from(type_name, &generics, quote!(&str));
 
     quote! {
         #impl_from_string

diff --git a/test_suite/tests/any.rs b/test_suite/tests/any.rs
@@ -488,6 +488,7 @@ mod with_generics {
     fn test_generic_with_lifetime_cow() {
         #[nutype(
             validate(predicate = |s| s.len() >= 3),
+            // TODO: derive TryFrom
             derive(Debug, Display, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Into)
         )]
         struct Clarabelle<'a>(Cow<'a, str>);