rand: Fix most clippy warnings

rand_chacha/src/chacha.rs

@@ -79,7 +79,7 @@ macro_rules! chacha_impl {
             fn generate(&mut self, r: &mut Self::Results) {
                 // Fill slice of words by writing to equivalent slice of bytes, then fixing endianness.
                 self.state.refill4($rounds, unsafe {
-                    core::mem::transmute::<&mut Array64<u32>, &mut [u8; 256]>(&mut *r)
+                    &mut *(&mut *r as *mut Array64<u32> as *mut [u8; 256])
                 });
                 for x in r.as_mut() {
                     *x = x.to_le();

rand_core/src/block.rs

@@ -188,6 +188,7 @@ where <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>
         let read_u64 = |results: &[u32], index| {
             if cfg!(any(target_endian = "little")) {
                 // requires little-endian CPU
+                #[allow(clippy::cast_ptr_alignment)]  // false positive
                 let ptr: *const u64 = results[index..=index+1].as_ptr() as *const u64;
                 unsafe { ptr::read_unaligned(ptr) }
             } else {
@@ -233,7 +234,8 @@ where <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>
 
     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        Ok(self.fill_bytes(dest))
+        self.fill_bytes(dest);
+        Ok(())
     }
 }
 
@@ -408,7 +410,8 @@ where <R as BlockRngCore>::Results: AsRef<[u64]> + AsMut<[u64]>
 
     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        Ok(self.fill_bytes(dest))
+        self.fill_bytes(dest);
+        Ok(())
     }
 }
 

rand_core/src/impls.rs

@@ -17,7 +17,6 @@
 //! to/from byte sequences, and since its purpose is reproducibility,
 //! non-reproducible sources (e.g. `OsRng`) need not bother with it.
 
-use core::intrinsics::transmute;
 use core::ptr::copy_nonoverlapping;
 use core::slice;
 use core::cmp::min;
@@ -44,21 +43,15 @@ pub fn fill_bytes_via_next<R: RngCore + ?Sized>(rng: &mut R, dest: &mut [u8]) {
     while left.len() >= 8 {
         let (l, r) = {left}.split_at_mut(8);
         left = r;
-        let chunk: [u8; 8] = unsafe {
-            transmute(rng.next_u64().to_le())
-        };
+        let chunk: [u8; 8] = rng.next_u64().to_le_bytes();
         l.copy_from_slice(&chunk);
     }
     let n = left.len();
     if n > 4 {
-        let chunk: [u8; 8] = unsafe {
-            transmute(rng.next_u64().to_le())
-        };
+        let chunk: [u8; 8] = rng.next_u64().to_le_bytes();
         left.copy_from_slice(&chunk[..n]);
     } else if n > 0 {
-        let chunk: [u8; 4] = unsafe {
-            transmute(rng.next_u32().to_le())
-        };
+        let chunk: [u8; 4] = rng.next_u32().to_le_bytes();
         left.copy_from_slice(&chunk[..n]);
     }
 }

rand_core/src/lib.rs

@@ -35,6 +35,8 @@
 #![deny(missing_debug_implementations)]
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
 
+#![allow(clippy::unreadable_literal)]
+
 #![cfg_attr(not(feature="std"), no_std)]
 #![cfg_attr(all(feature="alloc", not(feature="std")), feature(alloc))]
 

rand_distr/src/binomial.rs

@@ -65,6 +65,7 @@ fn f64_to_i64(x: f64) -> i64 {
 }
 
 impl Distribution<u64> for Binomial {
+    #[allow(clippy::many_single_char_names)]  // Same names as in the reference.
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
         // Handle these values directly.
         if self.p == 0.0 {

rand_distr/src/cauchy.rs

@@ -66,8 +66,7 @@ where Standard: Distribution<N>
         // note that π/2 is not exactly representable, even if x=0.5 the result is finite
         let comp_dev = (N::pi() * x).tan();
         // shift and scale according to parameters
-        let result = self.median + self.scale * comp_dev;
-        result
+        self.median + self.scale * comp_dev
     }
 }
 

rand_distr/src/dirichlet.rs

@@ -58,8 +58,8 @@ where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distributi
         if a.len() < 2 {
             return Err(Error::AlphaTooShort);
         }
-        for i in 0..a.len() {
-            if !(a[i] > N::from(0.0)) {
+        for &ai in &a {
+            if !(ai > N::from(0.0)) {
                 return Err(Error::AlphaTooSmall);
             }
         }
@@ -92,14 +92,14 @@ where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distributi
         let mut samples = vec![N::from(0.0); n];
         let mut sum = N::from(0.0);
 
-        for i in 0..n {
-            let g = Gamma::new(self.alpha[i], N::from(1.0)).unwrap();
-            samples[i] = g.sample(rng);
-            sum += samples[i];
+        for (s, &a) in samples.iter_mut().zip(self.alpha.iter()) {
+            let g = Gamma::new(a, N::from(1.0)).unwrap();
+            *s = g.sample(rng);
+            sum += *s;
         }
         let invacc = N::from(1.0) / sum;
-        for i in 0..n {
-            samples[i] *= invacc;
+        for s in samples.iter_mut() {
+            *s *= invacc;
         }
         samples
     }

rand_distr/src/lib.rs

@@ -13,6 +13,9 @@
 #![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 
+#![allow(clippy::excessive_precision, clippy::float_cmp, clippy::unreadable_literal)]
+#![allow(clippy::neg_cmp_op_on_partial_ord)]  // suggested fix too verbose
+
 //! Generating random samples from probability distributions.
 //!
 //! ## Re-exports

rand_distr/src/utils.rs

@@ -88,9 +88,9 @@ impl Float for f32 {
     fn tan(self) -> Self { self.tan() }
     #[inline]
     fn log_gamma(self) -> Self {
-        let result = log_gamma(self as f64);
-        assert!(result <= ::core::f32::MAX as f64);
-        assert!(result >= ::core::f32::MIN as f64);
+        let result = log_gamma(self.into());
+        assert!(result <= ::core::f32::MAX.into());
+        assert!(result >= ::core::f32::MIN.into());
         result as f32
     }
 }

rand_pcg/src/lib.rs

@@ -35,6 +35,8 @@
 #![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 
+#![allow(clippy::unreadable_literal)]
+
 #![no_std]
 
 mod pcg64;

rand_pcg/src/pcg128.rs

@@ -14,7 +14,6 @@
 const MULTIPLIER: u128 = 0x2360_ED05_1FC6_5DA4_4385_DF64_9FCC_F645;
 
 use core::fmt;
-use core::mem::transmute;
 use rand_core::{RngCore, SeedableRng, Error, le};
 #[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
 
@@ -86,8 +85,8 @@ impl SeedableRng for Lcg128Xsl64 {
     fn from_seed(seed: Self::Seed) -> Self {
         let mut seed_u64 = [0u64; 4];
         le::read_u64_into(&seed, &mut seed_u64);
-        let state = (seed_u64[0] as u128) | ((seed_u64[1] as u128) << 64);
-        let incr = (seed_u64[2] as u128) | ((seed_u64[3] as u128) << 64);
+        let state = u128::from(seed_u64[0]) | (u128::from(seed_u64[1]) << 64);
+        let incr = u128::from(seed_u64[2]) | (u128::from(seed_u64[3]) << 64);
 
         // The increment must be odd, hence we discard one bit:
         Lcg128Xsl64::from_state_incr(state, incr | 1)
@@ -113,7 +112,8 @@ impl RngCore for Lcg128Xsl64 {
 
     #[inline]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        Ok(self.fill_bytes(dest))
+        self.fill_bytes(dest);
+        Ok(())
     }
 }
 
@@ -166,8 +166,8 @@ impl SeedableRng for Mcg128Xsl64 {
         // Read as if a little-endian u128 value:
         let mut seed_u64 = [0u64; 2];
         le::read_u64_into(&seed, &mut seed_u64);
-        let state = (seed_u64[0] as u128) |
-                    (seed_u64[1] as u128) << 64;
+        let state = u128::from(seed_u64[0])  |
+                    u128::from(seed_u64[1]) << 64;
         Mcg128Xsl64::new(state)
     }
 }
@@ -191,7 +191,8 @@ impl RngCore for Mcg128Xsl64 {
 
     #[inline]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        Ok(self.fill_bytes(dest))
+        self.fill_bytes(dest);
+        Ok(())
     }
 }
 
@@ -213,16 +214,12 @@ fn fill_bytes_impl<R: RngCore + ?Sized>(rng: &mut R, dest: &mut [u8]) {
     while left.len() >= 8 {
         let (l, r) = {left}.split_at_mut(8);
         left = r;
-        let chunk: [u8; 8] = unsafe {
-            transmute(rng.next_u64().to_le())
-        };
+        let chunk: [u8; 8] = rng.next_u64().to_le_bytes();
         l.copy_from_slice(&chunk);
     }
     let n = left.len();
     if n > 0 {
-        let chunk: [u8; 8] = unsafe {
-            transmute(rng.next_u64().to_le())
-        };
+        let chunk: [u8; 8] = rng.next_u64().to_le_bytes();
         left.copy_from_slice(&chunk[..n]);
     }
 }

rand_pcg/src/pcg64.rs

@@ -121,6 +121,7 @@ impl RngCore for Lcg64Xsh32 {
 
     #[inline]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        Ok(self.fill_bytes(dest))
+        self.fill_bytes(dest);
+        Ok(())
     }
 }

rand_xorshift/src/lib.rs

@@ -71,7 +71,8 @@ impl RngCore for XorShiftRng {
     }
 
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        Ok(self.fill_bytes(dest))
+        self.fill_bytes(dest);
+        Ok(())
     }
 }
 

rand_xoshiro/src/lib.rs

@@ -62,7 +62,7 @@
 
 #![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
-#![cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))]
+#![allow(clippy::unreadable_literal)]
 #![no_std]
 
 #[macro_use]

src/distributions/bernoulli.rs

@@ -96,13 +96,13 @@ impl Bernoulli {
     /// return `true`. If `numerator == 0` it will always return `false`.
     #[inline]
     pub fn from_ratio(numerator: u32, denominator: u32) -> Result<Bernoulli, BernoulliError> {
-        if !(numerator <= denominator) {
+        if numerator > denominator {
             return Err(BernoulliError::InvalidProbability);
         }
         if numerator == denominator {
             return Ok(Bernoulli { p_int: ALWAYS_TRUE })
         }
-        let p_int = ((numerator as f64 / denominator as f64) * SCALE) as u64;
+        let p_int = ((f64::from(numerator) / f64::from(denominator)) * SCALE) as u64;
         Ok(Bernoulli { p_int })
     }
 }

src/distributions/binomial.rs

@@ -9,6 +9,7 @@
 
 //! The binomial distribution.
 #![allow(deprecated)]
+#![allow(clippy::all)]
 
 use crate::Rng;
 use crate::distributions::{Distribution, Uniform};

src/distributions/cauchy.rs

@@ -9,6 +9,7 @@
 
 //! The Cauchy distribution.
 #![allow(deprecated)]
+#![allow(clippy::all)]
 
 use crate::Rng;
 use crate::distributions::Distribution;

src/distributions/dirichlet.rs

@@ -9,6 +9,7 @@
 
 //! The dirichlet distribution.
 #![allow(deprecated)]
+#![allow(clippy::all)]
 
 use crate::Rng;
 use crate::distributions::Distribution;

src/distributions/float.rs

@@ -95,9 +95,7 @@ macro_rules! float_impls {
                 // The exponent is encoded using an offset-binary representation
                 let exponent_bits: $u_scalar =
                     (($exponent_bias + exponent) as $u_scalar) << $fraction_bits;
-                // TODO: use from_bits when min compiler > 1.25 (see #545)
-                // $ty::from_bits(self | exponent_bits)
-                unsafe{ mem::transmute(self | exponent_bits) }
+                $ty::from_bits(self | exponent_bits)
             }
         }
 

src/distributions/integer.rs

@@ -52,8 +52,8 @@ impl Distribution<u128> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
         // Use LE; we explicitly generate one value before the next.
-        let x = rng.next_u64() as u128;
-        let y = rng.next_u64() as u128;
+        let x = u128::from(rng.next_u64());
+        let y = u128::from(rng.next_u64());
         (y << 64) | x
     }
 }

src/distributions/mod.rs

@@ -213,7 +213,7 @@ pub trait Distribution<T> {
     {
         DistIter {
             distr: self,
-            rng: rng,
+            rng,
             phantom: ::core::marker::PhantomData,
         }
     }

src/distributions/other.rs

@@ -11,7 +11,7 @@
 use core::char;
 use core::num::Wrapping;
 
-use crate::{Rng};
+use crate::Rng;
 use crate::distributions::{Distribution, Standard, Uniform};
 
 // ----- Sampling distributions -----
@@ -116,6 +116,7 @@ macro_rules! tuple_impl {
 }
 
 impl Distribution<()> for Standard {
+    #[allow(clippy::unused_unit)]
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> () { () }
 }

src/distributions/uniform.rs

@@ -380,7 +380,7 @@ macro_rules! uniform_int_impl {
                 let range = high.wrapping_sub(low).wrapping_add(1) as $unsigned;
                 let ints_to_reject =
                     if range > 0 {
-                        let range = range as $u_large;
+                        let range = $u_large::from(range);
                         (unsigned_max - range + 1) % range
                     } else {
                         0
@@ -865,8 +865,8 @@ impl UniformSampler for UniformDuration {
         let mut high_n = high.subsec_nanos();
 
         if high_n < low_n {
-            high_s = high_s - 1;
-            high_n = high_n + 1_000_000_000;
+            high_s -= 1;
+            high_n += 1_000_000_000;
         }
 
         let mode = if low_s == high_s {
@@ -877,10 +877,10 @@ impl UniformSampler for UniformDuration {
         } else {
             let max = high_s
                 .checked_mul(1_000_000_000)
-                .and_then(|n| n.checked_add(high_n as u64));
+                .and_then(|n| n.checked_add(u64::from(high_n)));
 
             if let Some(higher_bound) = max {
-                let lower_bound = low_s * 1_000_000_000 + low_n as u64;
+                let lower_bound = low_s * 1_000_000_000 + u64::from(low_n);
                 UniformDurationMode::Medium {
                     nanos: Uniform::new_inclusive(lower_bound, higher_bound),
                 }

src/distributions/unit_circle.rs

@@ -7,6 +7,7 @@
 // except according to those terms.
 
 #![allow(deprecated)]
+#![allow(clippy::all)]
 
 use crate::Rng;
 use crate::distributions::{Distribution, Uniform};

src/distributions/unit_sphere.rs

@@ -7,6 +7,7 @@
 // except according to those terms.
 
 #![allow(deprecated)]
+#![allow(clippy::all)]
 
 use crate::Rng;
 use crate::distributions::{Distribution, Uniform};