Avoid 'unsigned' and 'type' as macro variable

It seems to break R1.15
rust-num · Jul 19, 2018 · de5b78c · de5b78c
1 parent 5fe8a5f
commit de5b78c
Show file tree

Hide file tree

Showing 2 changed files with 10 additions and 10 deletions.
diff --git a/src/bigint.rs b/src/bigint.rs
@@ -829,21 +829,21 @@ fn powsign<T: Integer>(sign: Sign, other: &T) -> Sign {
 }
 
 macro_rules! pow_impl {
-    ($type:ty) => {
-        impl<'a> Pow<$type> for &'a BigInt {
+    ($T:ty) => {
+        impl<'a> Pow<$T> for &'a BigInt {
             type Output = BigInt;
 
             #[inline]
-            fn pow(self, rhs: $type) -> BigInt {
+            fn pow(self, rhs: $T) -> BigInt {
                 BigInt::from_biguint(powsign(self.sign, &rhs), (&self.data).pow(rhs))
             }
         }
 
-        impl<'a, 'b> Pow<&'b $type> for &'a BigInt {
+        impl<'a, 'b> Pow<&'b $T> for &'a BigInt {
             type Output = BigInt;
 
             #[inline]
-            fn pow(self, rhs: &$type) -> BigInt {
+            fn pow(self, rhs: &$T) -> BigInt {
                 BigInt::from_biguint(powsign(self.sign, rhs), (&self.data).pow(rhs))
             }
         }

diff --git a/src/biguint.rs b/src/biguint.rs
@@ -435,12 +435,12 @@ impl One for BigUint {
 impl Unsigned for BigUint {}
 
 macro_rules! pow_impl {
-    ($unsigned:ty) => {
-        impl<'a> Pow<$unsigned> for &'a BigUint {
+    ($T:ty) => {
+        impl<'a> Pow<$T> for &'a BigUint {
             type Output = BigUint;
 
             #[inline]
-            fn pow(self, mut exp: $unsigned) -> Self::Output {
+            fn pow(self, mut exp: $T) -> Self::Output {
                 if exp == 0 { return BigUint::one(); }
                 let mut base = self.clone();
 
@@ -464,11 +464,11 @@ macro_rules! pow_impl {
             }
         }
 
-        impl<'a, 'b> Pow<&'b $unsigned> for &'a BigUint {
+        impl<'a, 'b> Pow<&'b $T> for &'a BigUint {
             type Output = BigUint;
 
             #[inline]
-            fn pow(self, exp: &$unsigned) -> Self::Output {
+            fn pow(self, exp: &$T) -> Self::Output {
                 self.pow(*exp)
             }
         }