Skip to content

Commit 1740ea8

Browse files
tbu-tbu-
committed
Add infrastructure to generate src/arrayvec_copy.rs
It works by replacing a couple of strings in `src/arrayvec.rs` and then applying a small patch. Check that the patch is up-to-date in CI.
1 parent 1982d40 commit 1740ea8

File tree

3 files changed

+196
-0
lines changed

3 files changed

+196
-0
lines changed

‎.github/workflows/ci.yml

+11
Original file line numberDiff line numberDiff line change
@@ -90,3 +90,14 @@ jobs:
9090
cargo miri setup
9191
- name: Test with Miri
9292
run: cargo miri test --all-features
93+
94+
check-generated:
95+
runs-on: ubuntu-latest
96+
steps:
97+
- uses: actions/checkout@v4
98+
- name: Regenerate src/arrayvec_copy.rs
99+
run: |
100+
rm src/arrayvec_copy.rs
101+
./generate_arrayvec_copy
102+
- name: Verify that nothing has changed
103+
run: test -z "$(git status --porcelain)"

‎generate_arrayvec_copy

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
#!/usr/bin/env bash
2+
set -o errexit
3+
set -o nounset
4+
set -o pipefail
5+
6+
sed \
7+
-e "s/\\<ArrayVec\\>/ArrayVecCopy/g" \
8+
-e "s/\\<ArrayVecVisitor\\>/ArrayVecCopyVisitor/g" \
9+
-e "s/impl<\\('a, \\)\\?T:/impl<\\1T: Copy +/g" \
10+
-e "s/impl<\\('a, \\)\\?T,/impl<\\1T: Copy,/g" \
11+
-e "s/struct \\([A-Za-z_]*\\)<\\('a, \\)\\?T:/struct \\1<\\2T: Copy +/g" \
12+
-e "s/struct \\([A-Za-z_]*\\)<\\('a, \\)\\?T,/struct \\1<\\2T: Copy,/g" \
13+
-e "s/fn \\([A-Za-z_]*\\)<\\('a, \\)\\?T:/fn \\1<\\2T: Copy +/g" \
14+
-e "s/fn \\([A-Za-z_]*\\)<\\('a, \\)\\?T,/fn \\1<\\2T: Copy,/g" \
15+
src/arrayvec.rs \
16+
> src/arrayvec_copy_generated.rs
17+
18+
trap "rm src/arrayvec_copy_generated.rs" EXIT
19+
20+
if [ -e src/arrayvec_copy.patch ]; then
21+
if [ -e src/arrayvec_copy.rs ]; then
22+
echo "Both src/arrayvec_copy.patch and src/arrayvec_copy.rs exist." > /dev/stderr
23+
echo "Delete one of them and start again." > /dev/stderr
24+
exit 1
25+
else
26+
patch -o src/arrayvec_copy.rs src/arrayvec_copy_generated.rs arrayvec_copy.patch > /dev/null
27+
fi
28+
else
29+
if [ -e src/arrayvec_copy.rs ]; then
30+
git diff --no-index src/arrayvec_copy_generated.rs src/arrayvec_copy.rs > src/arrayvec_copy.patch
31+
else
32+
echo "Both src/arrayvec_copy.patch and src/arrayvec_copy.rs are missing." > /dev/stderr
33+
echo "One of them is needed to generate the other." > /dev/stderr
34+
exit 1
35+
fi
36+
fi

‎src/arrayvec_copy.patch

+149
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,149 @@
1+
diff --git a/src/arrayvec_copy_generated.rs b/src/arrayvec_copy.rs
2+
index 2c32eed..ada0728 100644
3+
--- a/src/arrayvec_copy_generated.rs
4+
+++ b/src/arrayvec_copy.rs
5+
@@ -14,7 +14,6 @@ use std::fmt;
6+
#[cfg(feature="std")]
7+
use std::io;
8+
9+
-use std::mem::ManuallyDrop;
10+
use std::mem::MaybeUninit;
11+
12+
#[cfg(feature="serde")]
13+
@@ -25,7 +24,7 @@ use crate::errors::CapacityError;
14+
use crate::arrayvec_impl::ArrayVecImpl;
15+
use crate::utils::MakeMaybeUninit;
16+
17+
-/// A vector with a fixed capacity.
18+
+/// A vector with a fixed capacity which implements `Copy` and its elemenents are constrained to also be `Copy`.
19+
///
20+
/// The `ArrayVecCopy` is a vector backed by a fixed size array. It keeps track of
21+
/// the number of initialized elements. The `ArrayVecCopy<T, CAP>` is parameterized
22+
@@ -46,14 +45,6 @@ pub struct ArrayVecCopy<T: Copy, const CAP: usize> {
23+
xs: [MaybeUninit<T>; CAP],
24+
}
25+
26+
-impl<T: Copy, const CAP: usize> Drop for ArrayVecCopy<T, CAP> {
27+
- fn drop(&mut self) {
28+
- self.clear();
29+
-
30+
- // MaybeUninit inhibits array's drop
31+
- }
32+
-}
33+
-
34+
macro_rules! panic_oob {
35+
($method_name:expr, $index:expr, $len:expr) => {
36+
panic!(concat!("ArrayVecCopy::", $method_name, ": index {} is out of bounds in vector of length {}"),
37+
@@ -231,8 +222,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
38+
ArrayVecImpl::push_unchecked(self, element)
39+
}
40+
41+
- /// Shortens the vector, keeping the first `len` elements and dropping
42+
- /// the rest.
43+
+ /// Shortens the vector, keeping the first `len` elements.
44+
///
45+
/// If `len` is greater than the vector’s current length this has no
46+
/// effect.
47+
@@ -499,7 +489,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
48+
let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len };
49+
50+
#[inline(always)]
51+
- fn process_one<F: FnMut(&mut T) -> bool, T, const CAP: usize, const DELETED: bool>(
52+
+ fn process_one<T: Copy, F: FnMut(&mut T) -> bool, const CAP: usize, const DELETED: bool>(
53+
f: &mut F,
54+
g: &mut BackshiftOnDrop<'_, T, CAP>
55+
) -> bool {
56+
@@ -507,7 +497,6 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
57+
if !f(unsafe { &mut *cur }) {
58+
g.processed_len += 1;
59+
g.deleted_cnt += 1;
60+
- unsafe { ptr::drop_in_place(cur) };
61+
return false;
62+
}
63+
if DELETED {
64+
@@ -522,20 +511,20 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
65+
66+
// Stage 1: Nothing was deleted.
67+
while g.processed_len != original_len {
68+
- if !process_one::<F, T, CAP, false>(&mut f, &mut g) {
69+
+ if !process_one::<T, F, CAP, false>(&mut f, &mut g) {
70+
break;
71+
}
72+
}
73+
74+
// Stage 2: Some elements were deleted.
75+
while g.processed_len != original_len {
76+
- process_one::<F, T, CAP, true>(&mut f, &mut g);
77+
+ process_one::<T, F, CAP, true>(&mut f, &mut g);
78+
}
79+
80+
drop(g);
81+
}
82+
83+
- /// Set the vector’s length without dropping or moving out elements
84+
+ /// Set the vector’s length without moving out elements
85+
///
86+
/// This method is `unsafe` because it changes the notion of the
87+
/// number of “valid” elements in the vector. Use with care.
88+
@@ -668,8 +657,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
89+
/// This operation is safe if and only if length equals capacity.
90+
pub unsafe fn into_inner_unchecked(self) -> [T; CAP] {
91+
debug_assert_eq!(self.len(), self.capacity());
92+
- let self_ = ManuallyDrop::new(self);
93+
- let array = ptr::read(self_.as_ptr() as *const [T; CAP]);
94+
+ let array = ptr::read(self.as_ptr() as *const [T; CAP]);
95+
array
96+
}
97+
98+
@@ -755,10 +743,9 @@ impl<T: Copy, const CAP: usize> DerefMut for ArrayVecCopy<T, CAP> {
99+
impl<T: Copy, const CAP: usize> From<[T; CAP]> for ArrayVecCopy<T, CAP> {
100+
#[track_caller]
101+
fn from(array: [T; CAP]) -> Self {
102+
- let array = ManuallyDrop::new(array);
103+
let mut vec = <ArrayVecCopy<T, CAP>>::new();
104+
unsafe {
105+
- (&*array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
106+
+ (&array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
107+
.copy_to_nonoverlapping(&mut vec.xs as *mut [MaybeUninit<T>; CAP], 1);
108+
vec.set_len(CAP);
109+
}
110+
@@ -929,21 +916,6 @@ impl<T: Copy, const CAP: usize> DoubleEndedIterator for IntoIter<T, CAP> {
111+
112+
impl<T: Copy, const CAP: usize> ExactSizeIterator for IntoIter<T, CAP> { }
113+
114+
-impl<T: Copy, const CAP: usize> Drop for IntoIter<T, CAP> {
115+
- fn drop(&mut self) {
116+
- // panic safety: Set length to 0 before dropping elements.
117+
- let index = self.index;
118+
- let len = self.v.len();
119+
- unsafe {
120+
- self.v.set_len(0);
121+
- let elements = slice::from_raw_parts_mut(
122+
- self.v.get_unchecked_ptr(index),
123+
- len - index);
124+
- ptr::drop_in_place(elements);
125+
- }
126+
- }
127+
-}
128+
-
129+
impl<T: Copy, const CAP: usize> Clone for IntoIter<T, CAP>
130+
where T: Clone,
131+
{
132+
@@ -1029,7 +1001,7 @@ impl<'a, T: Copy + 'a, const CAP: usize> Drop for Drain<'a, T, CAP> {
133+
}
134+
}
135+
136+
-struct ScopeExitGuard<T: Copy, Data, F>
137+
+struct ScopeExitGuard<T, Data, F>
138+
where F: FnMut(&Data, &mut T)
139+
{
140+
value: T,
141+
@@ -1037,7 +1009,7 @@ struct ScopeExitGuard<T: Copy, Data, F>
142+
f: F,
143+
}
144+
145+
-impl<T: Copy, Data, F> Drop for ScopeExitGuard<T, Data, F>
146+
+impl<T, Data, F> Drop for ScopeExitGuard<T, Data, F>
147+
where F: FnMut(&Data, &mut T)
148+
{
149+
fn drop(&mut self) {

0 commit comments

Comments
 (0)