Merge pull request #343 from pitdicker/clippy

Clippy

Author: dhardy

benches/distributions.rs

@@ -74,9 +74,9 @@ macro_rules! distr {
 distr_int!(distr_range_i8, i8, Range::new(20i8, 100));
 distr_int!(distr_range_i16, i16, Range::new(-500i16, 2000));
 distr_int!(distr_range_i32, i32, Range::new(-200_000_000i32, 800_000_000));
-distr_int!(distr_range_i64, i64, Range::new(3i64, 12345678901234));
+distr_int!(distr_range_i64, i64, Range::new(3i64, 123_456_789_123));
 #[cfg(feature = "i128_support")]
-distr_int!(distr_range_i128, i128, Range::new(-12345678901234i128, 12345678901234567890));
+distr_int!(distr_range_i128, i128, Range::new(-123_456_789_123i128, 123_456_789_123_456_789));
 
 distr_float!(distr_range_f32, f32, Range::new(2.26f32, 2.319));
 distr_float!(distr_range_f64, f64, Range::new(2.26f64, 2.319));
@@ -97,9 +97,9 @@ distr_float!(distr_uniform_f32, f32, Uniform);
 distr_float!(distr_uniform_f64, f64, Uniform);
 
 // distributions
-distr_float!(distr_exp, f64, Exp::new(2.71828 * 3.14159));
-distr_float!(distr_normal, f64, Normal::new(-2.71828, 3.14159));
-distr_float!(distr_log_normal, f64, LogNormal::new(-2.71828, 3.14159));
+distr_float!(distr_exp, f64, Exp::new(1.23 * 4.56));
+distr_float!(distr_normal, f64, Normal::new(-1.23, 4.56));
+distr_float!(distr_log_normal, f64, LogNormal::new(-1.23, 4.56));
 distr_float!(distr_gamma_large_shape, f64, Gamma::new(10., 1.0));
 distr_float!(distr_gamma_small_shape, f64, Gamma::new(0.1, 1.0));
 distr_int!(distr_binomial, u64, Binomial::new(20, 0.7));
@@ -131,6 +131,6 @@ macro_rules! gen_range_int {
 gen_range_int!(gen_range_i8, i8, -20i8, 100);
 gen_range_int!(gen_range_i16, i16, -500i16, 2000);
 gen_range_int!(gen_range_i32, i32, -200_000_000i32, 800_000_000);
-gen_range_int!(gen_range_i64, i64, 3i64, 12345678901234);
+gen_range_int!(gen_range_i64, i64, 3i64, 123_456_789_123);
 #[cfg(feature = "i128_support")]
-gen_range_int!(gen_range_i128, i128, -12345678901234i128, 12345678901234567890);
+gen_range_int!(gen_range_i128, i128, -12345678901234i128, 123_456_789_123_456_789);

rand_core/src/error.rs

@@ -99,10 +99,10 @@ impl Error {
     /// Create a new instance, with specified kind and a message.
     pub fn new(kind: ErrorKind, msg: &'static str) -> Self {
         #[cfg(feature="std")] {
-            Error { kind: kind, msg: msg, cause: None }
+            Error { kind, msg, cause: None }
         }
         #[cfg(not(feature="std"))] {
-            Error { kind: kind, msg: msg }
+            Error { kind, msg }
         }
     }
 
@@ -119,7 +119,7 @@ impl Error {
     pub fn with_cause<E>(kind: ErrorKind, msg: &'static str, cause: E) -> Self
         where E: Into<Box<stdError + Send + Sync>>
     {
-        Error { kind: kind, msg: msg, cause: Some(cause.into()) }
+        Error { kind, msg, cause: Some(cause.into()) }
     }
 
     /// Create a new instance, with specified kind, message, and a
@@ -128,7 +128,7 @@ impl Error {
     /// In `no_std` mode the *cause* is ignored.
     #[cfg(not(feature="std"))]
     pub fn with_cause<E>(kind: ErrorKind, msg: &'static str, _cause: E) -> Self {
-        Error { kind: kind, msg: msg }
+        Error { kind, msg }
     }
 
     /// Take the cause, if any. This allows the embedded cause to be extracted.

rand_core/src/impls.rs

@@ -30,8 +30,8 @@ use {RngCore, BlockRngCore, CryptoRng, SeedableRng, Error};
 /// Implement `next_u64` via `next_u32`, little-endian order.
 pub fn next_u64_via_u32<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
     // Use LE; we explicitly generate one value before the next.
-    let x = rng.next_u32() as u64;
-    let y = rng.next_u32() as u64;
+    let x = u64::from(rng.next_u32());
+    let y = u64::from(rng.next_u32());
     (y << 32) | x
 }
 
@@ -223,8 +223,8 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
                 // requires little-endian CPU supporting unaligned reads:
                 unsafe { *(&results[index] as *const u32 as *const u64) }
             } else {
-                let x = results[index] as u64;
-                let y = results[index + 1] as u64;
+                let x = u64::from(results[index]);
+                let y = u64::from(results[index + 1]);
                 (y << 32) | x
             }
         };
@@ -241,10 +241,10 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
             self.index = 2;
             read_u64(self.results.as_ref(), 0)
         } else {
-            let x = self.results.as_ref()[len-1] as u64;
+            let x = u64::from(self.results.as_ref()[len-1]);
             self.core.generate(&mut self.results);
             self.index = 1;
-            let y = self.results.as_ref()[0] as u64;
+            let y = u64::from(self.results.as_ref()[0]);
             (y << 32) | x
         }
     }
@@ -272,7 +272,8 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
 
         while filled < end_direct {
             let dest_u32: &mut R::Results = unsafe {
-                ::core::mem::transmute(dest[filled..].as_mut_ptr())
+                &mut *(dest[filled..].as_mut_ptr() as
+                *mut <R as BlockRngCore>::Results)
             };
             self.core.generate(dest_u32);
             filled += self.results.as_ref().len() * 4;
@@ -282,7 +283,7 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
         if len_remainder > 0 {
             self.core.generate(&mut self.results);
             let (consumed_u32, _) =
-                fill_via_u32_chunks(&mut self.results.as_ref(),
+                fill_via_u32_chunks(self.results.as_ref(),
                                     &mut dest[filled..]);
 
             self.index = consumed_u32;
@@ -307,7 +308,8 @@ where <R as BlockRngCore>::Results: AsRef<[u32]>
     }
 
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        Ok(self.fill_bytes(dest))
+        self.fill_bytes(dest);
+        Ok(())
     }
 }