[rpms/rust-circular-buffer] epel9: EPEL9: Patch for Rust 1.92

[Benjamin A. Beasley <code@musicinmybrain.net>]

A new commit has been pushed.

Repo   : rpms/rust-circular-buffer
Branch : epel9
Commit : c0be996b07262883478ab9c2df46e79a49043b0b
Author : Benjamin A. Beasley <code@musicinmybrain.net>
Date   : 2026-07-17T07:01:50+01:00
Stats  : +219/-1 in 4 file(s)
URL    : https://src.fedoraproject.org/rpms/rust-circular-buffer/c/c0be996b07262883478ab9c2df46e79a49043b0b?branch=epel9

Log:
EPEL9: Patch for Rust 1.92

---
diff --git a/0001-EPEL9-Revert-Use-stabilized-Rust-features.patch b/0001-EPEL9-Revert-Use-stabilized-Rust-features.patch
new file mode 100644
index 0000000..427aa8b
--- /dev/null
+++ b/0001-EPEL9-Revert-Use-stabilized-Rust-features.patch
@@ -0,0 +1,188 @@
+From ecabab9dabcb25a1a1378cf8c67f12ba4a9bcc93 Mon Sep 17 00:00:00 2001
+From: "Benjamin A. Beasley" <code@musicinmybrain.net>
+Date: Fri, 17 Jul 2026 06:51:23 +0100
+Subject: [PATCH] EPEL9: Revert "Use stabilized Rust features"
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Don’t require Rust 1.93 yet; EPEL9 has 1.92 for now.
+
+This reverts commit 2cf0a457fc60af1e9d1cd99e0349aa5844fe7fd4.
+---
+ src/drain.rs |  6 +++--
+ src/lib.rs   | 74 +++++++++++++++++++++++++++++++++++++++++++++++-----
+ 2 files changed, 71 insertions(+), 9 deletions(-)
+
+diff --git a/src/drain.rs b/src/drain.rs
+index 286693d..485b3b8 100644
+--- a/src/drain.rs
++++ b/src/drain.rs
+@@ -5,6 +5,8 @@ use crate::CircularBuffer;
+ use crate::add_mod;
+ use crate::iter::Iter;
+ use crate::iter::translate_range_bounds;
++use crate::slice_assume_init_mut;
++use crate::slice_assume_init_ref;
+ use core::fmt;
+ use core::iter::FusedIterator;
+ use core::marker::PhantomData;
+@@ -132,7 +134,7 @@ impl<'a, T> Drain<'a, T> {
+         };
+ 
+         // SAFETY: The elements in these slices are guaranteed to be initialized
+-        unsafe { (right.assume_init_ref(), left.assume_init_ref()) }
++        unsafe { (slice_assume_init_ref(right), slice_assume_init_ref(left)) }
+     }
+ 
+     fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) {
+@@ -160,7 +162,7 @@ impl<'a, T> Drain<'a, T> {
+         };
+ 
+         // SAFETY: The elements in these slices are guaranteed to be initialized
+-        unsafe { (right.assume_init_mut(), left.assume_init_mut()) }
++        unsafe { (slice_assume_init_mut(right), slice_assume_init_mut(left)) }
+     }
+ }
+ 
+diff --git a/src/lib.rs b/src/lib.rs
+index c852d3f..f15dc22 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -303,6 +303,22 @@ const fn sub_mod(x: usize, y: usize, m: usize) -> usize {
+     add_mod(x, m - y, m)
+ }
+ 
++#[inline]
++const unsafe fn slice_assume_init_ref<T>(slice: &[MaybeUninit<T>]) -> &[T] {
++    // TODO: replace with `slice.assume_init_ref()` once it's stabilized
++    //
++    // SAFETY: upheld by the caller
++    unsafe { &*(slice as *const [MaybeUninit<T>] as *const [T]) }
++}
++
++#[inline]
++unsafe fn slice_assume_init_mut<T>(slice: &mut [MaybeUninit<T>]) -> &mut [T] {
++    // TODO: replace with `slice.assume_init_mut()` once it's stabilized
++    //
++    // SAFETY: upheld by the caller
++    unsafe { &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) }
++}
++
+ /// Internal structure shared by `CircularBuffer`, `FixedCircularBuffer`, and `HeapCircularBuffer`.
+ ///
+ /// The main purpose of this structure is to allow safe coercion to `CircularBuffer`. It may go
+@@ -690,7 +706,7 @@ impl<T> CircularBuffer<T> {
+         };
+ 
+         // SAFETY: The elements in the slice are guaranteed to be initialized
+-        unsafe { slice.assume_init_mut() }
++        unsafe { slice_assume_init_mut(slice) }
+     }
+ 
+     /// Returns a pair of slices which contain the elements of this buffer.
+@@ -737,7 +753,7 @@ impl<T> CircularBuffer<T> {
+         };
+ 
+         // SAFETY: The elements in these slices are guaranteed to be initialized
+-        unsafe { (front.assume_init_ref(), back.assume_init_ref()) }
++        unsafe { (slice_assume_init_ref(front), slice_assume_init_ref(back)) }
+     }
+ 
+     /// Returns a pair of mutable slices which contain the elements of this buffer.
+@@ -789,7 +805,7 @@ impl<T> CircularBuffer<T> {
+         };
+ 
+         // SAFETY: The elements in these slices are guaranteed to be initialized
+-        unsafe { (front.assume_init_mut(), back.assume_init_mut()) }
++        unsafe { (slice_assume_init_mut(front), slice_assume_init_mut(back)) }
+     }
+ 
+     #[inline]
+@@ -917,7 +933,7 @@ impl<T> CircularBuffer<T> {
+                 // SAFETY: the caller of `drop_range` is responsible to check that this slice was
+                 // initialized.
+                 unsafe {
+-                    ptr::drop_in_place(self.0.assume_init_mut());
++                    ptr::drop_in_place(slice_assume_init_mut(self.0));
+                 }
+             }
+         }
+@@ -1936,6 +1952,50 @@ where
+         debug_assert!(self.inner.start < self.capacity(), "start out-of-bounds");
+         debug_assert!(self.inner.size <= self.capacity(), "size out-of-bounds");
+ 
++        // TODO: replace with `slice.write_clone_of_slice()` once it's stabilized
++        fn write_uninit_slice_cloned<T: Clone>(dst: &mut [MaybeUninit<T>], src: &[T]) {
++            // Each call to `clone()` may panic, therefore we need to track how many elements we
++            // successfully cloned so that we can drop them in case of panic. This `Guard` struct
++            // does exactly that: it keeps track of how many items have been successfully cloned
++            // and drops them if the guard is dropped.
++            //
++            // This implementation was highly inspired by the implementation of
++            // `MaybeUninit::clone_from_slice`
++            struct Guard<'a, T> {
++                dst: &'a mut [MaybeUninit<T>],
++                initialized: usize,
++            }
++
++            impl<T> Drop for Guard<'_, T> {
++                fn drop(&mut self) {
++                    let initialized = &mut self.dst[..self.initialized];
++                    // SAFETY: this slice contain only initialized objects; `MaybeUninit<T>` has
++                    // the same alignment and size as `T`
++                    unsafe {
++                        let initialized =
++                            &mut *(initialized as *mut [MaybeUninit<T>] as *mut [T]);
++                        ptr::drop_in_place(initialized);
++                    }
++                }
++            }
++
++            debug_assert_eq!(dst.len(), src.len());
++            let len = dst.len();
++            let mut guard = Guard {
++                dst,
++                initialized: 0,
++            };
++            #[allow(clippy::needless_range_loop)]
++            for i in 0..len {
++                guard.dst[i].write(src[i].clone());
++                guard.initialized += 1;
++            }
++
++            // All the `clone()` calls succeded; get rid of the guard without running its `drop()`
++            // implementation
++            mem::forget(guard);
++        }
++
+         if other.len() < self.capacity() {
+             // All the elements of `other` fit into the buffer
+             let free_size = self.capacity() - self.inner.size;
+@@ -1952,12 +2012,12 @@ where
+             let (right, left) = self.slices_uninit_mut();
+ 
+             let write_len = core::cmp::min(right.len(), other.len());
+-            right[..write_len].write_clone_of_slice(&other[..write_len]);
++            write_uninit_slice_cloned(&mut right[..write_len], &other[..write_len]);
+ 
+             let other = &other[write_len..];
+             debug_assert!(left.len() >= other.len());
+             let write_len = other.len();
+-            left[..write_len].write_clone_of_slice(other);
++            write_uninit_slice_cloned(&mut left[..write_len], other);
+ 
+             self.inner.size = final_size;
+         } else {
+@@ -1968,7 +2028,7 @@ where
+ 
+             let other = &other[other.len() - self.capacity()..];
+             debug_assert_eq!(self.inner.items.len(), other.len());
+-            self.inner.items.write_clone_of_slice(other);
++            write_uninit_slice_cloned(&mut self.inner.items, other);
+ 
+             self.inner.size = self.capacity();
+         }
+-- 
+2.55.0
+

diff --git a/circular-buffer-fix-metadata.diff b/circular-buffer-fix-metadata.diff
index f446c22..33af930 100644
--- a/circular-buffer-fix-metadata.diff
+++ b/circular-buffer-fix-metadata.diff
@@ -1,5 +1,14 @@
 --- circular-buffer-2.0.0/Cargo.toml	2006-07-24T01:21:28+00:00
-+++ circular-buffer-2.0.0/Cargo.toml	2026-07-02T06:58:29.289943+00:00
++++ circular-buffer-2.0.0/Cargo.toml	2026-07-17T06:01:41.637917+00:00
+@@ -11,7 +11,7 @@
+ 
+ [package]
+ edition = "2024"
+-rust-version = "1.93.0"
++rust-version = "1.87"
+ name = "circular-buffer"
+ version = "2.0.0"
+ authors = ["Andrea Corbellini <corbellini.andrea@gmail.com>"]
 @@ -79,9 +79,6 @@
  optional = true
  default-features = false

diff --git a/rust-circular-buffer.spec b/rust-circular-buffer.spec
index 2246ed2..2d27c47 100644
--- a/rust-circular-buffer.spec
+++ b/rust-circular-buffer.spec
@@ -14,7 +14,14 @@ URL:            https://crates.io/crates/circular-buffer
 Source:         %{crates_source}
 # Manually created patch for downstream crate metadata changes
 # * Do not depend on criterion; it is needed only for benchmarks.
+# * EPEL9: allow Rust 1.92 (and back to 1.87); see
+#   0001-EPEL9-Revert-Use-stabilized-Rust-features.patch.
 Patch:          circular-buffer-fix-metadata.diff
+# * EPEL9: Revert "Use stabilized Rust features"
+# * Don’t require Rust 1.93 yet; EPEL9 has 1.92 for now.
+# * This reverts commit 2cf0a457fc60af1e9d1cd99e0349aa5844fe7fd4.
+# * This is the source changes only.
+Patch10:        0001-EPEL9-Revert-Use-stabilized-Rust-features.patch
 
 BuildRequires:  cargo-rpm-macros >= 24
 

diff --git a/rust2rpm.toml b/rust2rpm.toml
index 25b65b9..f86eaf6 100644
--- a/rust2rpm.toml
+++ b/rust2rpm.toml
@@ -1,6 +1,20 @@
 [package]
 cargo-toml-patch-comments = [
     "Do not depend on criterion; it is needed only for benchmarks.",
+    """\
+EPEL9: allow Rust 1.92 (and back to 1.87); see \
+0001-EPEL9-Revert-Use-stabilized-Rust-features.patch.\
+""",
+]
+
+[[package.extra-patches]]
+number = 10
+file = "0001-EPEL9-Revert-Use-stabilized-Rust-features.patch"
+comments = [
+    "EPEL9: Revert \"Use stabilized Rust features\"",
+    "Don’t require Rust 1.93 yet; EPEL9 has 1.92 for now.",
+    "This reverts commit 2cf0a457fc60af1e9d1cd99e0349aa5844fe7fd4.",
+    "This is the source changes only.",
 ]
 
 [features]