Fix various warnings

Warnings reported by CI and by `cargo clippy --all-targets --all-features -- -D warnings`

Author: aleb

benches/benches/generators.rs

@@ -196,7 +196,7 @@ pub fn reseeding_bytes(c: &mut Criterion) {
     g.throughput(criterion::Throughput::Bytes(1024 * 1024));
 
     fn bench(g: &mut BenchmarkGroup<WallTime>, thresh: u64) {
-        let name = format!("chacha20_{}k", thresh);
+        let name = format!("chacha20_{thresh}k");
         g.bench_function(name.as_str(), |b| {
             let mut rng = ReseedingRng::<ChaCha20Core, _>::new(thresh * 1024, OsRng).unwrap();
             let mut buf = [0u8; 1024 * 1024];

benches/benches/seq_choose.rs

@@ -30,7 +30,7 @@ pub fn bench(c: &mut Criterion) {
 
     let lens = [(1, 1000), (950, 1000), (10, 100), (90, 100)];
     for (amount, len) in lens {
-        let name = format!("seq_slice_choose_multiple_{}_of_{}", amount, len);
+        let name = format!("seq_slice_choose_multiple_{amount}_of_{len}");
         c.bench_function(name.as_str(), |b| {
             let mut rng = Pcg32::from_rng(&mut rand::rng());
             let mut buf = [0i32; 1000];
@@ -54,7 +54,7 @@ pub fn bench(c: &mut Criterion) {
 
     let lens = [(1, 1000), (950, 1000), (10, 100), (90, 100)];
     for (amount, len) in lens {
-        let name = format!("seq_slice_choose_multiple_weighted_{}_of_{}", amount, len);
+        let name = format!("seq_slice_choose_multiple_weighted_{amount}_of_{len}");
         c.bench_function(name.as_str(), |b| {
             let mut rng = Pcg32::from_rng(&mut rand::rng());
             let mut buf = [0i32; 1000];

benches/benches/weighted.rs

@@ -49,7 +49,7 @@ pub fn bench(c: &mut Criterion) {
         (1000, 1_000_000, "1M"),
     ];
     for (amount, length, len_name) in lens {
-        let name = format!("weighted_sample_indices_{}_of_{}", amount, len_name);
+        let name = format!("weighted_sample_indices_{amount}_of_{len_name}");
         c.bench_function(name.as_str(), |b| {
             let length = black_box(length);
             let amount = black_box(amount);

rand_core/src/block.rs

@@ -557,7 +557,7 @@ mod test {
         }
         rng.next_u32();
 
-        let result = rng.next_u64();
+        let _ = rng.next_u64();
         assert_eq!(rng.index(), 1);
     }
 }

rand_core/src/impls.rs

@@ -179,39 +179,39 @@ mod test {
     fn test_fill_via_u32_chunks() {
         let src_orig = [1u32, 2, 3];
 
-        let mut src = src_orig;
+        let src = src_orig;
         let mut dst = [0u8; 11];
-        assert_eq!(fill_via_chunks(&mut src, &mut dst), (3, 11));
+        assert_eq!(fill_via_chunks(&src, &mut dst), (3, 11));
         assert_eq!(dst, [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0]);
 
-        let mut src = src_orig;
+        let src = src_orig;
         let mut dst = [0u8; 13];
-        assert_eq!(fill_via_chunks(&mut src, &mut dst), (3, 12));
+        assert_eq!(fill_via_chunks(&src, &mut dst), (3, 12));
         assert_eq!(dst, [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0]);
 
-        let mut src = src_orig;
+        let src = src_orig;
         let mut dst = [0u8; 5];
-        assert_eq!(fill_via_chunks(&mut src, &mut dst), (2, 5));
+        assert_eq!(fill_via_chunks(&src, &mut dst), (2, 5));
         assert_eq!(dst, [1, 0, 0, 0, 2]);
     }
 
     #[test]
     fn test_fill_via_u64_chunks() {
         let src_orig = [1u64, 2];
 
-        let mut src = src_orig;
+        let src = src_orig;
         let mut dst = [0u8; 11];
-        assert_eq!(fill_via_chunks(&mut src, &mut dst), (2, 11));
+        assert_eq!(fill_via_chunks(&src, &mut dst), (2, 11));
         assert_eq!(dst, [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0]);
 
-        let mut src = src_orig;
+        let src = src_orig;
         let mut dst = [0u8; 17];
-        assert_eq!(fill_via_chunks(&mut src, &mut dst), (2, 16));
+        assert_eq!(fill_via_chunks(&src, &mut dst), (2, 16));
         assert_eq!(dst, [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]);
 
-        let mut src = src_orig;
+        let src = src_orig;
         let mut dst = [0u8; 5];
-        assert_eq!(fill_via_chunks(&mut src, &mut dst), (1, 5));
+        assert_eq!(fill_via_chunks(&src, &mut dst), (1, 5));
         assert_eq!(dst, [1, 0, 0, 0, 0]);
     }
 }

rand_core/src/lib.rs

@@ -764,9 +764,11 @@ mod test {
         let mut rng = rng.unwrap_mut();
 
         assert_eq!(rng.next_u32(), 4);
-        let mut rng2 = rng.re();
-        assert_eq!(rng2.next_u32(), 4);
-        drop(rng2);
+        {
+            let mut rng2 = rng.re();
+            assert_eq!(rng2.next_u32(), 4);
+            // Make sure rng2 is dropped.
+        }
         assert_eq!(rng.next_u32(), 4);
     }
 }

src/seq/iterator.rs

@@ -137,6 +137,10 @@ pub trait IteratorRandom: Iterator + Sized {
     //
     // Clippy is wrong here: we need to iterate over all entries with the RNG to
     // ensure that choosing is *stable*.
+    // "allow(unknown_lints)" can be removed when switching to at least
+    // rust-version 1.86.0, see:
+    // https://rust-lang.github.io/rust-clippy/master/index.html#double_ended_iterator_last
+    #[allow(unknown_lints)]
     #[allow(clippy::double_ended_iterator_last)]
     fn choose_stable<R>(mut self, rng: &mut R) -> Option<Self::Item>
     where

src/seq/slice.rs

@@ -87,7 +87,11 @@ pub trait IndexedRandom: Index<usize> {
     /// }
     /// ```
     #[cfg(feature = "alloc")]
-    fn choose_multiple<R>(&self, rng: &mut R, amount: usize) -> SliceChooseIter<Self, Self::Output>
+    fn choose_multiple<R>(
+        &self,
+        rng: &mut R,
+        amount: usize,
+    ) -> SliceChooseIter<'_, Self, Self::Output>
     where
         Self::Output: Sized,
         R: Rng + ?Sized,
@@ -209,7 +213,7 @@ pub trait IndexedRandom: Index<usize> {
         rng: &mut R,
         amount: usize,
         weight: F,
-    ) -> Result<SliceChooseIter<Self, Self::Output>, WeightError>
+    ) -> Result<SliceChooseIter<'_, Self, Self::Output>, WeightError>
     where
         Self::Output: Sized,
         R: Rng + ?Sized,