Introduce rand_core::impl_try_* macros instead of blanket impl

Author: newpavlov

rand_chacha/src/chacha.rs

@@ -253,6 +253,8 @@ macro_rules! chacha_impl {
 
         impl CryptoRng for $ChaChaXRng {}
 
+        rand_core::impl_try_crypto_rng_from_crypto_rng!($ChaChaXRng);
+
         impl From<$ChaChaXCore> for $ChaChaXRng {
             fn from(core: $ChaChaXCore) -> Self {
                 $ChaChaXRng {

rand_core/src/blanket_impls.rs

@@ -0,0 +1,90 @@
+#[cfg(feature = "alloc")] use alloc::boxed::Box;
+
+use crate::{CryptoRng, RngCore, TryCryptoRng, TryRngCore};
+
+impl<'a, R: RngCore + ?Sized> RngCore for &'a mut R {
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        R::next_u32(self)
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        R::next_u64(self)
+    }
+
+    #[inline(always)]
+    fn fill_bytes(&mut self, dst: &mut [u8]) {
+        R::fill_bytes(self, dst)
+    }
+}
+
+impl<'a, R: CryptoRng + ?Sized> CryptoRng for &'a mut R {}
+
+impl<'a, R: TryRngCore + ?Sized> TryRngCore for &'a mut R {
+    type Error = R::Error;
+
+    #[inline(always)]
+    fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
+        R::try_next_u32(self)
+    }
+
+    #[inline(always)]
+    fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
+        R::try_next_u64(self)
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> {
+        R::try_fill_bytes(self, dst)
+    }
+}
+
+impl<'a, R: TryCryptoRng + ?Sized> TryCryptoRng for &'a mut R {}
+
+#[cfg(feature = "alloc")]
+impl<R: RngCore + ?Sized> RngCore for Box<R> {
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        R::next_u32(self)
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        R::next_u64(self)
+    }
+
+    #[inline(always)]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        R::fill_bytes(self, dest)
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+impl<R: CryptoRng + ?Sized> CryptoRng for Box<R> {}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+impl<R: TryRngCore + ?Sized> TryRngCore for Box<R> {
+    type Error = R::Error;
+
+    #[inline(always)]
+    fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
+        R::try_next_u32(self)
+    }
+
+    #[inline(always)]
+    fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
+        R::try_next_u64(self)
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> {
+        R::try_fill_bytes(self, dst)
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+impl<R: TryCryptoRng + ?Sized> TryCryptoRng for Box<R> {}

rand_core/src/block.rs

@@ -54,7 +54,7 @@
 //! [`fill_bytes`]: RngCore::fill_bytes
 
 use crate::impls::{fill_via_u32_chunks, fill_via_u64_chunks};
-use crate::{CryptoRng, RngCore, SeedableRng};
+use crate::{CryptoRng, RngCore, SeedableRng, TryRngCore};
 use core::fmt;
 #[cfg(feature = "serde1")] use serde::{Deserialize, Serialize};
 
@@ -249,9 +249,14 @@ impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng<R> {
     }
 
     #[inline(always)]
-    fn from_rng<S: RngCore>(rng: S) -> Self {
+    fn from_rng(rng: impl RngCore) -> Self {
         Self::new(R::from_rng(rng))
     }
+
+    #[inline(always)]
+    fn try_from_rng<S: TryRngCore>(rng: S) -> Result<Self, S::Error> {
+        R::try_from_rng(rng).map(Self::new)
+    }
 }
 
 impl<R: CryptoBlockRng + BlockRngCore<Item = u32>> CryptoRng for BlockRng<R> {}
@@ -409,9 +414,14 @@ impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng64<R> {
     }
 
     #[inline(always)]
-    fn from_rng<S: RngCore>(rng: S) -> Self {
+    fn from_rng(rng: impl RngCore) -> Self {
         Self::new(R::from_rng(rng))
     }
+
+    #[inline(always)]
+    fn try_from_rng<S: TryRngCore>(rng: S) -> Result<Self, S::Error> {
+        R::try_from_rng(rng).map(Self::new)
+    }
 }
 
 impl<R: CryptoBlockRng + BlockRngCore<Item = u64>> CryptoRng for BlockRng64<R> {}

rand_core/src/impls.rs

@@ -160,6 +160,49 @@ pub fn next_u64_via_fill<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
     u64::from_le_bytes(buf)
 }
 
+/// Implement [`TryRngCore`] for a type implementing [`RngCore`].
+///
+/// Ideally, `rand_core` would define blanket impls for this, but they conflict with blanket impls
+/// for `&mut R` and `Box<R>`, so until specialziation is stabilized, implementer crates
+/// have to implement `TryRngCore` directly.
+#[macro_export]
+macro_rules! impl_try_rng_from_rng_core {
+    ($t:ty) => {
+        impl $crate::TryRngCore for $t {
+            type Error = core::convert::Infallible;
+
+            #[inline]
+            fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
+                Ok(self.next_u32())
+            }
+
+            #[inline]
+            fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
+                Ok(self.next_u64())
+            }
+
+            #[inline]
+            fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> {
+                self.fill_bytes(dst);
+                Ok(())
+            }
+        }
+    };
+}
+
+/// Implement [`TryCryptoRng`] for a type implementing [`CryptoRng`].
+///
+/// Ideally, `rand_core` would define blanket impls for this, but they conflict with blanket impls
+/// for `&mut R` and `Box<R>`, so until specialziation is stabilized, implementer crates
+/// have to implement `TryRngCore` and `TryCryptoRng` directly.
+#[macro_export]
+macro_rules! impl_try_crypto_rng_from_crypto_rng {
+    ($t:ty) => {
+        $crate::impl_try_rng_from_rng_core!($t);
+        impl $crate::TryCryptoRng for $t {}
+    };
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

rand_core/src/lib.rs

@@ -37,10 +37,10 @@
 
 #[cfg(feature = "alloc")] extern crate alloc;
 #[cfg(feature = "std")] extern crate std;
-#[cfg(feature = "alloc")] use alloc::boxed::Box;
 
-use core::{convert::Infallible, fmt};
+use core::fmt;
 
+mod blanket_impls;
 pub mod block;
 pub mod impls;
 pub mod le;
@@ -207,28 +207,6 @@ pub trait TryRngCore {
 /// See [`CryptoRng`] docs for more information.
 pub trait TryCryptoRng: TryRngCore {}
 
-impl<R: RngCore> TryRngCore for R {
-    type Error = Infallible;
-
-    #[inline]
-    fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
-        Ok(self.next_u32())
-    }
-
-    #[inline]
-    fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
-        Ok(self.next_u64())
-    }
-
-    #[inline]
-    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> {
-        self.fill_bytes(dst);
-        Ok(())
-    }
-}
-
-impl<R: CryptoRng> TryCryptoRng for R {}
-
 /// Wrapper around [`TryCryptoRng`] implementation which implements [`RngCore`]
 /// by panicking on potential errors.
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
@@ -401,7 +379,7 @@ pub trait SeedableRng: Sized {
     /// (in prior versions this was not required).
     ///
     /// [`rand`]: https://docs.rs/rand
-    fn from_rng<R: RngCore>(mut rng: R) -> Self {
+    fn from_rng(mut rng: impl RngCore) -> Self {
         let mut seed = Self::Seed::default();
         rng.fill_bytes(seed.as_mut());
         Self::from_seed(seed)
@@ -410,7 +388,7 @@ pub trait SeedableRng: Sized {
     /// Create a new PRNG seeded from a potentially fallible `Rng`.
     ///
     /// See [`from_rng`][SeedableRng::from_rng] docs for more infromation.
-    fn try_from_rng<R: TryRngCore>(rng: &mut R) -> Result<Self, R::Error> {
+    fn try_from_rng<R: TryRngCore>(mut rng: R) -> Result<Self, R::Error> {
         let mut seed = Self::Seed::default();
         rng.try_fill_bytes(seed.as_mut())?;
         Ok(Self::from_seed(seed))
@@ -461,47 +439,6 @@ pub trait SeedableRng: Sized {
     }
 }
 
-impl<'a, R: RngCore + ?Sized> RngCore for &'a mut R {
-    #[inline(always)]
-    fn next_u32(&mut self) -> u32 {
-        R::next_u32(self)
-    }
-
-    #[inline(always)]
-    fn next_u64(&mut self) -> u64 {
-        R::next_u64(self)
-    }
-
-    #[inline(always)]
-    fn fill_bytes(&mut self, dst: &mut [u8]) {
-        R::fill_bytes(self, dst)
-    }
-}
-
-impl<'a, R: CryptoRng + ?Sized> CryptoRng for &'a mut R {}
-
-#[cfg(feature = "alloc")]
-impl<R: RngCore + ?Sized> RngCore for Box<R> {
-    #[inline(always)]
-    fn next_u32(&mut self) -> u32 {
-        R::next_u32(self)
-    }
-
-    #[inline(always)]
-    fn next_u64(&mut self) -> u64 {
-        R::next_u64(self)
-    }
-
-    #[inline(always)]
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
-        R::fill_bytes(self, dest)
-    }
-}
-
-#[cfg(feature = "alloc")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
-impl<R: CryptoRng + ?Sized> CryptoRng for Box<R> {}
-
 /// Adapter that enables reading through a [`io::Read`](std::io::Read) from a [`RngCore`].
 ///
 /// # Examples

src/rngs/mock.rs

@@ -74,6 +74,8 @@ impl RngCore for StepRng {
     }
 }
 
+rand_core::impl_try_rng_from_rng_core!(StepRng);
+
 #[cfg(test)]
 mod tests {
     #[cfg(any(feature = "alloc", feature = "serde1"))] use super::StepRng;

src/rngs/small.rs

@@ -59,6 +59,8 @@ impl RngCore for SmallRng {
     }
 }
 
+rand_core::impl_try_rng_from_rng_core!(SmallRng);
+
 impl SmallRng {
     /// Construct an instance seeded from another `Rng`
     ///

src/rngs/std.rs

@@ -63,6 +63,7 @@ impl SeedableRng for StdRng {
 
 impl CryptoRng for StdRng {}
 
+rand_core::impl_try_crypto_rng_from_crypto_rng!(StdRng);
 
 #[cfg(test)]
 mod test {

src/rngs/thread.rs

@@ -179,6 +179,7 @@ impl RngCore for ThreadRng {
 
 impl CryptoRng for ThreadRng {}
 
+rand_core::impl_try_crypto_rng_from_crypto_rng!(ThreadRng);
 
 #[cfg(test)]
 mod test {

src/rngs/xoshiro128plusplus.rs

@@ -91,6 +91,8 @@ impl RngCore for Xoshiro128PlusPlus {
     }
 }
 
+rand_core::impl_try_rng_from_rng_core!(Xoshiro128PlusPlus);
+
 #[cfg(test)]
 mod tests {
     use super::Xoshiro128PlusPlus;

src/rngs/xoshiro256plusplus.rs

@@ -94,6 +94,8 @@ impl RngCore for Xoshiro256PlusPlus {
     }
 }
 
+rand_core::impl_try_rng_from_rng_core!(Xoshiro256PlusPlus);
+
 #[cfg(test)]
 mod tests {
     use super::Xoshiro256PlusPlus;