Implement derives for generic wrapper types

Author: Oliver Scherer

src/lib.rs

@@ -165,10 +165,16 @@ fn newtype_inner(data: &syn::Data) -> Option<syn::Type> {
 pub fn from_primitive(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
 
     let impl_ = if let Some(inner_ty) = newtype_inner(&ast.data) {
+        let bound = quote! { #inner_ty: _num_traits::FromPrimitive };
+        let where_ = match where_ {
+            Some(where_) => quote!{ #where_, #bound },
+            None => quote!{ where #bound },
+        };
         quote! {
-            impl _num_traits::FromPrimitive for #name {
+            impl #impl_ _num_traits::FromPrimitive for #name #type_ #where_ {
                 fn from_i64(n: i64) -> Option<Self> {
                     <#inner_ty as _num_traits::FromPrimitive>::from_i64(n).map(#name)
                 }
@@ -251,7 +257,7 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {
         };
 
         quote! {
-            impl _num_traits::FromPrimitive for #name {
+            impl #impl_ _num_traits::FromPrimitive for #name #type_ #where_ {
                 #[allow(trivial_numeric_casts)]
                 fn from_i64(#from_i64_var: i64) -> Option<Self> {
                     #(#clauses else)* {
@@ -321,10 +327,16 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {
 pub fn to_primitive(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
 
     let impl_ = if let Some(inner_ty) = newtype_inner(&ast.data) {
+        let bound = quote! { #inner_ty: _num_traits::ToPrimitive };
+        let where_ = match where_ {
+            Some(where_) => quote!{ #where_, #bound },
+            None => quote!{ where #bound },
+        };
         quote! {
-            impl _num_traits::ToPrimitive for #name {
+            impl #impl_ _num_traits::ToPrimitive for #name #type_ #where_ {
                 fn to_i64(&self) -> Option<i64> {
                     <#inner_ty as _num_traits::ToPrimitive>::to_i64(&self.0)
                 }
@@ -410,7 +422,7 @@ pub fn to_primitive(input: TokenStream) -> TokenStream {
         };
 
         quote! {
-            impl _num_traits::ToPrimitive for #name {
+            impl #impl_ _num_traits::ToPrimitive for #name #type_ #where_ {
                 #[allow(trivial_numeric_casts)]
                 fn to_i64(&self) -> Option<i64> {
                     #match_expr
@@ -440,36 +452,41 @@ const NEWTYPE_ONLY: &str = "This trait can only be derived for newtypes";
 pub fn num_ops(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
     let inner_ty = newtype_inner(&ast.data).expect(NEWTYPE_ONLY);
+    let where_ = match where_ {
+        Some(where_) => quote!{ #where_, },
+        None => quote!{ where },
+    };
     dummy_const_trick(
         "NumOps",
         &name,
         quote! {
-            impl ::std::ops::Add for #name {
+            impl #impl_ ::std::ops::Add for #name #type_ #where_ #inner_ty: ::std::ops::Add<Output = #inner_ty> {
                 type Output = Self;
                 fn add(self, other: Self) -> Self {
                     #name(<#inner_ty as ::std::ops::Add>::add(self.0, other.0))
                 }
             }
-            impl ::std::ops::Sub for #name {
+            impl #impl_ ::std::ops::Sub for #name #type_ #where_ #inner_ty: ::std::ops::Sub<Output = #inner_ty> {
                 type Output = Self;
                 fn sub(self, other: Self) -> Self {
                     #name(<#inner_ty as ::std::ops::Sub>::sub(self.0, other.0))
                 }
             }
-            impl ::std::ops::Mul for #name {
+            impl #impl_ ::std::ops::Mul for #name #type_ #where_ #inner_ty: ::std::ops::Mul<Output = #inner_ty> {
                 type Output = Self;
                 fn mul(self, other: Self) -> Self {
                     #name(<#inner_ty as ::std::ops::Mul>::mul(self.0, other.0))
                 }
             }
-            impl ::std::ops::Div for #name {
+            impl #impl_ ::std::ops::Div for #name #type_ #where_ #inner_ty: ::std::ops::Div<Output = #inner_ty> {
                 type Output = Self;
                 fn div(self, other: Self) -> Self {
                     #name(<#inner_ty as ::std::ops::Div>::div(self.0, other.0))
                 }
             }
-            impl ::std::ops::Rem for #name {
+            impl #impl_ ::std::ops::Rem for #name #type_ #where_ #inner_ty: ::std::ops::Rem<Output = #inner_ty> {
                 type Output = Self;
                 fn rem(self, other: Self) -> Self {
                     #name(<#inner_ty as ::std::ops::Rem>::rem(self.0, other.0))
@@ -488,13 +505,20 @@ pub fn num_ops(input: TokenStream) -> TokenStream {
 pub fn num_cast(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
     let inner_ty = newtype_inner(&ast.data).expect(NEWTYPE_ONLY);
+    let where_ = match where_ {
+        Some(where_) => quote!{ #where_,  },
+        None => quote!{ where },
+    };
+    let fn_param = proc_macro2::Ident::new("FROM_T", name.span());
     dummy_const_trick(
         "NumCast",
         &name,
         quote! {
-            impl _num_traits::NumCast for #name {
-                fn from<T: _num_traits::ToPrimitive>(n: T) -> Option<Self> {
+            impl #impl_ _num_traits::NumCast for #name #type_ #where_ #inner_ty: _num_traits::NumCast {
+                #[allow(non_camel_case_types)]
+                fn from<#fn_param: _num_traits::ToPrimitive>(n: #fn_param) -> Option<Self> {
                     <#inner_ty as _num_traits::NumCast>::from(n).map(#name)
                 }
             }
@@ -510,12 +534,17 @@ pub fn num_cast(input: TokenStream) -> TokenStream {
 pub fn zero(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
     let inner_ty = newtype_inner(&ast.data).expect(NEWTYPE_ONLY);
+    let where_ = match where_ {
+        Some(where_) => quote!{ #where_, },
+        None => quote!{ where },
+    };
     dummy_const_trick(
         "Zero",
         &name,
         quote! {
-            impl _num_traits::Zero for #name {
+            impl #impl_ _num_traits::Zero for #name #type_ #where_ #inner_ty: _num_traits::Zero {
                 fn zero() -> Self {
                     #name(<#inner_ty as _num_traits::Zero>::zero())
                 }
@@ -535,12 +564,17 @@ pub fn zero(input: TokenStream) -> TokenStream {
 pub fn one(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
     let inner_ty = newtype_inner(&ast.data).expect(NEWTYPE_ONLY);
+    let where_ = match where_ {
+        Some(where_) => quote!{ #where_, },
+        None => quote!{ where },
+    };
     dummy_const_trick(
         "One",
         &name,
         quote! {
-            impl _num_traits::One for #name {
+            impl #impl_ _num_traits::One for #name #type_ #where_ #inner_ty: _num_traits::One + PartialEq {
                 fn one() -> Self {
                     #name(<#inner_ty as _num_traits::One>::one())
                 }
@@ -560,12 +594,17 @@ pub fn one(input: TokenStream) -> TokenStream {
 pub fn num(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
     let inner_ty = newtype_inner(&ast.data).expect(NEWTYPE_ONLY);
+    let where_ = match where_ {
+        Some(where_) => quote!{ #where_, },
+        None => quote!{ where },
+    };
     dummy_const_trick(
         "Num",
         &name,
         quote! {
-            impl _num_traits::Num for #name {
+            impl #impl_ _num_traits::Num for #name #type_ #where_ #inner_ty: _num_traits::Num {
                 type FromStrRadixErr = <#inner_ty as _num_traits::Num>::FromStrRadixErr;
                 fn from_str_radix(s: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
                     <#inner_ty as _num_traits::Num>::from_str_radix(s, radix).map(#name)
@@ -584,12 +623,17 @@ pub fn num(input: TokenStream) -> TokenStream {
 pub fn float(input: TokenStream) -> TokenStream {
     let ast: syn::DeriveInput = syn::parse(input).unwrap();
     let name = &ast.ident;
+    let (impl_, type_, where_) = &ast.generics.split_for_impl();
     let inner_ty = newtype_inner(&ast.data).expect(NEWTYPE_ONLY);
+    let where_ = match where_ {
+        Some(where_) => quote!{ #where_, },
+        None => quote!{ where },
+    };
     dummy_const_trick(
         "Float",
         &name,
         quote! {
-            impl _num_traits::Float for #name {
+            impl #impl_ _num_traits::Float for #name #type_ #where_ #inner_ty: _num_traits::Float {
                 fn nan() -> Self {
                     #name(<#inner_ty as _num_traits::Float>::nan())
                 }

tests/generic_newtype.rs

@@ -0,0 +1,95 @@
+extern crate num as num_renamed;
+#[macro_use]
+extern crate num_derive;
+
+use crate::num_renamed::{Float, FromPrimitive, Num, NumCast, One, ToPrimitive, Zero};
+use std::ops::Neg;
+
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    PartialOrd,
+    ToPrimitive,
+    FromPrimitive,
+    NumOps,
+    NumCast,
+    One,
+    Zero,
+    Num,
+    Float,
+)]
+struct MyThing<T: Cake>(T) where T: Lie;
+
+trait Cake {}
+trait Lie {}
+
+impl Cake for f32 {}
+impl Lie for f32 {}
+
+impl<T: Neg<Output = T> + Cake + Lie> Neg for MyThing<T> {
+    type Output = Self;
+    fn neg(self) -> Self {
+        MyThing(self.0.neg())
+    }
+}
+
+#[test]
+fn test_from_primitive() {
+    assert_eq!(MyThing::from_u32(25), Some(MyThing(25.0)));
+}
+
+#[test]
+fn test_from_primitive_128() {
+    assert_eq!(
+        MyThing::from_i128(std::i128::MIN),
+        Some(MyThing((-2.0).powi(127)))
+    );
+}
+
+#[test]
+fn test_to_primitive() {
+    assert_eq!(MyThing(25.0).to_u32(), Some(25));
+}
+
+#[test]
+fn test_to_primitive_128() {
+    let f: MyThing<f32> = MyThing::from_f32(std::f32::MAX).unwrap();
+    assert_eq!(f.to_i128(), None);
+    assert_eq!(f.to_u128(), Some(0xffff_ff00_0000_0000_0000_0000_0000_0000));
+}
+
+#[test]
+fn test_num_ops() {
+    assert_eq!(MyThing(25.0) + MyThing(10.0), MyThing(35.0));
+    assert_eq!(MyThing(25.0) - MyThing(10.0), MyThing(15.0));
+    assert_eq!(MyThing(25.0) * MyThing(2.0), MyThing(50.0));
+    assert_eq!(MyThing(25.0) / MyThing(10.0), MyThing(2.5));
+    assert_eq!(MyThing(25.0) % MyThing(10.0), MyThing(5.0));
+}
+
+#[test]
+fn test_num_cast() {
+    assert_eq!(<MyThing<f32> as NumCast>::from(25u8), Some(MyThing(25.0)));
+}
+
+#[test]
+fn test_zero() {
+    assert_eq!(MyThing::zero(), MyThing(0.0));
+}
+
+#[test]
+fn test_one() {
+    assert_eq!(MyThing::one(), MyThing(1.0));
+}
+
+#[test]
+fn test_num() {
+    assert_eq!(MyThing::from_str_radix("25", 10).ok(), Some(MyThing(25.0)));
+}
+
+#[test]
+fn test_float() {
+    assert_eq!(MyThing(4.0).log(MyThing(2.0)), MyThing(2.0));
+}