Generate ArrayVecCopy without using patch

Invent this little hack, insert directives like this in ArrayVec:

```rust
// DIRECTIVE ArrayVecCopy #[cfg(not_in_arrayvec_copy)]
```

And replace them as follows in ArrayVecCopy:

```rust
\#[cfg(not_in_arrayvec_copy)]
```

Author: bluss

Cargo.toml

@@ -60,3 +60,7 @@ features = ["borsh", "serde", "zeroize"]
 [package.metadata.release]
 no-dev-version = true
 tag-name = "{{version}}"
+
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(not_in_arrayvec_copy)'] }

generate_arrayvec_copy

@@ -3,6 +3,13 @@ set -o errexit
 set -o nounset
 set -o pipefail
 
+# Generate ArrayVecCopy from ArrayVec
+# Replace type name with ArrayVecCopy
+# Insert `T: Copy` bound as needed.
+#
+# Replace `// DIRECTIVE ArrayVecCopy` with empty string anywhere to allow
+# items to be cfg'ed out for arrayvec copy
+
 sed \
        -e "s/\\<ArrayVec\\>/ArrayVecCopy/g" \
        -e "s/\\<ArrayVecVisitor\\>/ArrayVecCopyVisitor/g" \
@@ -13,25 +20,8 @@ sed \
        -e "s/fn \\([A-Za-z_]*\\)<\\('[A-Za-z_]*, \\)\\?T:/fn \\1<\\2T: Copy +/g" \
        -e "s/fn \\([A-Za-z_]*\\)<\\('[A-Za-z_]*, \\)\\?T,/fn \\1<\\2T: Copy,/g" \
        -e "s/const fn/fn/" \
+       -e "s/\\/\\/ DIRECTIVE ArrayVecCopy \\+//" \
        src/arrayvec.rs \
        > src/arrayvec_copy_generated.rs
 
-trap "rm src/arrayvec_copy_generated.rs" EXIT
-
-if [ -e src/arrayvec_copy.patch ]; then
-	if [ -e src/arrayvec_copy.rs ]; then
-		echo "Both src/arrayvec_copy.patch and src/arrayvec_copy.rs exist." > /dev/stderr
-		echo "Delete one of them and start again." > /dev/stderr
-		exit 1
-	else
-		patch -o src/arrayvec_copy.rs src/arrayvec_copy_generated.rs src/arrayvec_copy.patch > /dev/null
-	fi
-else
-	if [ -e src/arrayvec_copy.rs ]; then
-		git diff --no-index src/arrayvec_copy_generated.rs src/arrayvec_copy.rs > src/arrayvec_copy.patch || true
-	else
-		echo "Both src/arrayvec_copy.patch and src/arrayvec_copy.rs are missing." > /dev/stderr
-		echo "One of them is needed to generate the other." > /dev/stderr
-		exit 1
-	fi
-fi
+mv -v -f src/arrayvec_copy_generated.rs src/arrayvec_copy.rs

src/arrayvec.rs

@@ -1,3 +1,11 @@
+// The ArrayVec and ArrayVecCopy implementation
+//
+// NOTE: arrayvec.rs is the original source of both arrayvec.rs and arrayvec_copy.rs.
+// NOTE: Do not modify arrayvec_copy.rs manually. It is generated using the script
+// ./generate_arrayvec_copy.
+//
+// Any lines marked with a comment and then `DIRECTIVE ArrayVecCopy` will have that prefix removed
+// and have the rest of the line active in the ArrayVecCopy implementation.
 
 use std::cmp;
 use std::iter;
@@ -23,6 +31,7 @@ use serde::{Serialize, Deserialize, Serializer, Deserializer};
 use crate::LenUint;
 use crate::errors::CapacityError;
 use crate::arrayvec_impl::ArrayVecImpl;
+// DIRECTIVE ArrayVecCopy #[cfg(not_in_arrayvec_copy)]
 use crate::utils::MakeMaybeUninit;
 
 /// A vector with a fixed capacity.
@@ -39,13 +48,17 @@ use crate::utils::MakeMaybeUninit;
 ///
 /// It offers a simple API but also dereferences to a slice, so that the full slice API is
 /// available. The ArrayVec can be converted into a by value iterator.
+// DIRECTIVE ArrayVecCopy #[doc = ""]
+// DIRECTIVE ArrayVecCopy #[doc = "**ArrayVecCopy's only difference to [`\x41rrayVec`](crate::\x41rrayVec) is that its"]
+// DIRECTIVE ArrayVecCopy #[doc = "elements are constrained to be `Copy` which allows it to be `Copy` itself.** "]
 #[repr(C)]
 pub struct ArrayVec<T, const CAP: usize> {
     len: LenUint,
     // the `len` first elements of the array are initialized
     xs: [MaybeUninit<T>; CAP],
 }
 
+// DIRECTIVE ArrayVecCopy #[cfg(not_in_arrayvec_copy)]
 impl<T, const CAP: usize> Drop for ArrayVec<T, CAP> {
     fn drop(&mut self) {
         self.clear();
@@ -87,6 +100,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
         }
     }
 
+    // DIRECTIVE ArrayVecCopy #[cfg(not_in_arrayvec_copy)]
     /// Create a new empty `ArrayVec` (const fn).
     ///
     /// The maximum capacity is given by the generic parameter `CAP`.
@@ -964,6 +978,7 @@ impl<T, const CAP: usize> DoubleEndedIterator for IntoIter<T, CAP> {
 
 impl<T, const CAP: usize> ExactSizeIterator for IntoIter<T, CAP> { }
 
+// DIRECTIVE ArrayVecCopy #[cfg(not_in_arrayvec_copy)]
 impl<T, const CAP: usize> Drop for IntoIter<T, CAP> {
     fn drop(&mut self) {
         // panic safety: Set length to 0 before dropping elements.

src/arrayvec_copy.patch

@@ -1,3 +1,11 @@
+// The ArrayVecCopy and ArrayVecCopy implementation
+//
+// NOTE: arrayvec.rs is the original source of both arrayvec.rs and arrayvec_copy.rs.
+// NOTE: Do not modify arrayvec_copy.rs manually. It is generated using the script
+// ./generate_arrayvec_copy.
+//
+// Any lines marked with a comment and then `DIRECTIVE ArrayVecCopy` will have that prefix removed
+// and have the rest of the line active in the ArrayVecCopy implementation.
 
 use std::cmp;
 use std::iter;
@@ -23,12 +31,11 @@ use serde::{Serialize, Deserialize, Serializer, Deserializer};
 use crate::LenUint;
 use crate::errors::CapacityError;
 use crate::arrayvec_impl::ArrayVecImpl;
+#[cfg(not_in_arrayvec_copy)]
+use crate::utils::MakeMaybeUninit;
 
 /// A vector with a fixed capacity.
 ///
-/// **Its only difference to [`ArrayVec`](crate::ArrayVec) is that its elements
-/// are constrained to be `Copy` which allows it to be `Copy` itself.**
-///
 /// The `ArrayVecCopy` is a vector backed by a fixed size array. It keeps track of
 /// the number of initialized elements. The `ArrayVecCopy<T, CAP>` is parameterized
 /// by `T` for the element type and `CAP` for the maximum capacity.
@@ -41,13 +48,25 @@ use crate::arrayvec_impl::ArrayVecImpl;
 ///
 /// It offers a simple API but also dereferences to a slice, so that the full slice API is
 /// available. The ArrayVecCopy can be converted into a by value iterator.
+#[doc = ""]
+#[doc = "**ArrayVecCopy's only difference to [`\x41rrayVec`](crate::\x41rrayVec) is that its"]
+#[doc = "elements are constrained to be `Copy` which allows it to be `Copy` itself.** "]
 #[repr(C)]
 pub struct ArrayVecCopy<T: Copy, const CAP: usize> {
     len: LenUint,
     // the `len` first elements of the array are initialized
     xs: [MaybeUninit<T>; CAP],
 }
 
+#[cfg(not_in_arrayvec_copy)]
+impl<T: Copy, const CAP: usize> Drop for ArrayVecCopy<T, CAP> {
+    fn drop(&mut self) {
+        self.clear();
+
+        // MaybeUninit inhibits array's drop
+    }
+}
+
 macro_rules! panic_oob {
     ($method_name:expr, $index:expr, $len:expr) => {
         panic!(concat!("ArrayVecCopy::", $method_name, ": index {} is out of bounds in vector of length {}"),
@@ -81,6 +100,21 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
         }
     }
 
+    #[cfg(not_in_arrayvec_copy)]
+    /// Create a new empty `ArrayVecCopy` (fn).
+    ///
+    /// The maximum capacity is given by the generic parameter `CAP`.
+    ///
+    /// ```
+    /// use arrayvec::ArrayVecCopy;
+    ///
+    /// static ARRAY: ArrayVecCopy<u8, 1024> = ArrayVecCopy::new_const();
+    /// ```
+    pub fn new_const() -> ArrayVecCopy<T, CAP> {
+        assert_capacity_limit_const!(CAP);
+        ArrayVecCopy { xs: MakeMaybeUninit::ARRAY, len: 0 }
+    }
+
     /// Return the number of elements in the `ArrayVecCopy`.
     ///
     /// ```
@@ -944,6 +978,22 @@ impl<T: Copy, const CAP: usize> DoubleEndedIterator for IntoIter<T, CAP> {
 
 impl<T: Copy, const CAP: usize> ExactSizeIterator for IntoIter<T, CAP> { }
 
+#[cfg(not_in_arrayvec_copy)]
+impl<T: Copy, const CAP: usize> Drop for IntoIter<T, CAP> {
+    fn drop(&mut self) {
+        // panic safety: Set length to 0 before dropping elements.
+        let index = self.index;
+        let len = self.v.len();
+        unsafe {
+            self.v.set_len(0);
+            let elements = slice::from_raw_parts_mut(
+                self.v.get_unchecked_ptr(index),
+                len - index);
+            ptr::drop_in_place(elements);
+        }
+    }
+}
+
 impl<T: Copy, const CAP: usize> Clone for IntoIter<T, CAP>
 where T: Clone,
 {