Make UniformUsize serializable (#1646)

- [x] Added a `CHANGELOG.md` entry


# Motivation
This allows `WeightedIndex<usize>` to be serializable.

Author: aleb

CHANGELOG.md

@@ -12,6 +12,9 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
 ### Deprecated
 - Deprecate `rand::rngs::mock` module and `StepRng` generator (#1634)
 
+### Additions
+- Enable `WeightedIndex<usize>` (de)serialization (#1646)
+
 ## [0.9.1] - 2025-04-17
 ### Security and unsafe
 - Revise "not a crypto library" policy again (#1565)

Cargo.toml

@@ -81,3 +81,4 @@ rand_pcg = { path = "rand_pcg", version = "0.9.0" }
 # Only to test serde
 bincode = "1.2.1"
 rayon = "1.7"
+serde_json = "1.0.140"

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/distr/uniform_int.rs

@@ -402,11 +402,28 @@ uniform_simd_int_impl! { (u8, i8), (u16, i16), (u32, i32), (u64, i64) }
 /// this implementation will use 32-bit sampling when possible.
 #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(all(feature = "serde"), derive(Serialize))]
+// To be able to deserialize on 32-bit we need to replace this with a custom
+// implementation of the Deserialize trait, to be able to:
+// - panic when `mode64` is `true` on 32-bit,
+// - assign the default value to `mode64` when it's missing on 64-bit,
+// - panic when the `usize` fields are greater than `u32::MAX` on 32-bit.
+#[cfg_attr(
+    all(feature = "serde", target_pointer_width = "64"),
+    derive(Deserialize)
+)]
 pub struct UniformUsize {
+    /// The lowest possible value.
     low: usize,
+    /// The number of possible values. `0` has a special meaning: all.
     range: usize,
+    /// Threshold used when sampling to obtain a uniform distribution.
     thresh: usize,
+    /// Whether the largest possible value is greater than `u32::MAX`.
     #[cfg(target_pointer_width = "64")]
+    // Handle missing field when deserializing on 64-bit an object serialized
+    // on 32-bit. Can be removed when switching to a custom deserializer.
+    #[cfg_attr(feature = "serde", serde(default))]
     mode64: bool,
 }
 
@@ -793,4 +810,94 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_uniform_usize_empty_range() {
+        assert_eq!(UniformUsize::new(10, 10), Err(Error::EmptyRange));
+        assert!(UniformUsize::new(10, 11).is_ok());
+
+        assert_eq!(UniformUsize::new_inclusive(10, 9), Err(Error::EmptyRange));
+        assert!(UniformUsize::new_inclusive(10, 10).is_ok());
+    }
+
+    #[test]
+    fn test_uniform_usize_constructors() {
+        assert_eq!(
+            UniformUsize::new_inclusive(u32::MAX as usize, u32::MAX as usize),
+            Ok(UniformUsize {
+                low: u32::MAX as usize,
+                range: 1,
+                thresh: 0,
+                #[cfg(target_pointer_width = "64")]
+                mode64: false
+            })
+        );
+        assert_eq!(
+            UniformUsize::new_inclusive(0, u32::MAX as usize),
+            Ok(UniformUsize {
+                low: 0,
+                range: 0,
+                thresh: 0,
+                #[cfg(target_pointer_width = "64")]
+                mode64: false
+            })
+        );
+        #[cfg(target_pointer_width = "64")]
+        assert_eq!(
+            UniformUsize::new_inclusive(0, u32::MAX as usize + 1),
+            Ok(UniformUsize {
+                low: 0,
+                range: u32::MAX as usize + 2,
+                thresh: 1,
+                mode64: true
+            })
+        );
+        #[cfg(target_pointer_width = "64")]
+        assert_eq!(
+            UniformUsize::new_inclusive(u32::MAX as usize, u64::MAX as usize),
+            Ok(UniformUsize {
+                low: u32::MAX as usize,
+                range: u64::MAX as usize - u32::MAX as usize + 1,
+                thresh: u32::MAX as usize,
+                mode64: true
+            })
+        );
+    }
+
+    // This could be run also on 32-bit when deserialization is implemented.
+    #[cfg(all(feature = "serde", target_pointer_width = "64"))]
+    #[test]
+    fn test_uniform_usize_deserialization() {
+        use serde_json;
+        let original = UniformUsize::new_inclusive(10, 100).expect("creation");
+        let serialized = serde_json::to_string(&original).expect("serialization");
+        let deserialized: UniformUsize =
+            serde_json::from_str(&serialized).expect("deserialization");
+        assert_eq!(deserialized, original);
+    }
+
+    #[cfg(all(feature = "serde", target_pointer_width = "64"))]
+    #[test]
+    fn test_uniform_usize_deserialization_from_32bit() {
+        use serde_json;
+        let serialized_on_32bit = r#"{"low":10,"range":91,"thresh":74}"#;
+        let deserialized: UniformUsize =
+            serde_json::from_str(&serialized_on_32bit).expect("deserialization");
+        assert_eq!(
+            deserialized,
+            UniformUsize::new_inclusive(10, 100).expect("creation")
+        );
+    }
+
+    #[cfg(all(feature = "serde", target_pointer_width = "64"))]
+    #[test]
+    fn test_uniform_usize_deserialization_64bit() {
+        use serde_json;
+        let original = UniformUsize::new_inclusive(1, u64::MAX as usize - 1).expect("creation");
+        assert!(original.mode64);
+        let serialized = serde_json::to_string(&original).expect("serialization");
+        let deserialized: UniformUsize =
+            serde_json::from_str(&serialized).expect("deserialization");
+        assert_eq!(deserialized, original);
+    }
 }

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