less

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

vortex-array/benches/take_slices_to_buffer_matrix.rs

@@ -4,7 +4,7 @@
 //! Microbenchmarks for primitive `take_slices_to_buffer` copy-loop variants.
 //!
 //! The matrix covers:
-//! - append via `BufferMut::copy_from_slice`, indexed cursor copy, and advancing pointer copy
+//! - append via `BufferMut::extend_from_slice`, indexed cursor copy, and advancing pointer copy
 //!   into spare output capacity
 //! - ordinary checked slicing vs a preverification pass followed by unchecked slicing
 //! - fixed-width short slices at the run counts used by the FSL take benchmarks
@@ -157,7 +157,7 @@ fn take_extend_safe(
 ) -> Buffer<u16> {
     let mut result = BufferMut::<u16>::with_capacity(output_len);
     for (&start, &length) in starts.iter().zip(lengths) {
-        result.copy_from_slice(&values[start..start + length]);
+        result.extend_from_slice(&values[start..start + length]);
     }
     result.freeze()
 }
@@ -223,7 +223,7 @@ fn take_preverify_extend_unchecked(
     for (&start, &length) in starts.iter().zip(lengths) {
         // SAFETY: `preverify` checked every source range.
         unsafe {
-            result.copy_from_slice(values.get_unchecked(start..start + length));
+            result.extend_from_slice(values.get_unchecked(start..start + length));
         }
     }
     result.freeze()

vortex-array/src/arrays/filter/execute/slice.rs

@@ -121,7 +121,7 @@ pub(super) fn filter_slice_by_slices<T: Copy>(
 ) -> Buffer<T> {
     let mut out = BufferMut::<T>::with_capacity(output_len);
     for (start, end) in slices {
-        out.copy_from_slice(&slice[*start..*end]);
+        out.extend_from_slice(&slice[*start..*end]);
     }
 
     out.freeze()

vortex-array/src/arrays/varbin/compute/take.rs

@@ -389,7 +389,7 @@ fn take<Index: IntegerPType, Offset: IntegerPType>(
         let stop = offsets[idx + 1]
             .to_usize()
             .vortex_expect("Failed to cast max offset to usize");
-        new_data.copy_from_slice(&data[start..stop]);
+        new_data.extend_from_slice(&data[start..stop]);
     }
 
     let array_validity = Validity::from(dtype.nullability());
@@ -798,7 +798,7 @@ fn take_nullable<Index: IntegerPType, Offset: IntegerPType>(
         let stop = offsets[data_idx + 1]
             .to_usize()
             .vortex_expect("Failed to cast max offset to usize");
-        new_data.copy_from_slice(&data[start..stop]);
+        new_data.extend_from_slice(&data[start..stop]);
     }
 
     let array_validity = Validity::from(validity_buffer.freeze());

vortex-array/src/builders/primitive.rs

@@ -160,7 +160,7 @@ impl<T: NativePType> PrimitiveBuilder<T> {
             "Cannot append primitive array with different ptype"
         );
 
-        self.values.copy_from_slice(array.as_slice::<T>());
+        self.values.extend_from_slice(array.as_slice::<T>());
         self.nulls.append_validity_mask(
             &array
                 .as_ref()

vortex-buffer/src/buffer_mut.rs

@@ -401,7 +401,7 @@ impl<T> BufferMut<T> {
             preferred_alignment,
             allocator,
         );
-        buffer.copy_from_slice(other);
+        buffer.extend_from_slice(other);
         debug_assert_eq!(buffer.alignment(), alignment);
         buffer
     }
@@ -681,48 +681,17 @@ impl<T> BufferMut<T> {
         self.length += n;
     }
 
-    /// Appends a slice by cloning its elements, growing the internal buffer as needed.
-    ///
-    /// Prefer [`Self::copy_from_slice`] when `T` implements `Copy`.
-    ///
-    /// # Panics
-    ///
-    /// If cloning an element panics, the buffer's length and existing values are unchanged.
-    ///
-    /// # Example:
-    ///
-    /// ```
-    /// # use vortex_buffer::BufferMut;
-    ///
-    /// let mut builder = BufferMut::<u16>::with_capacity(10);
-    /// builder.extend_from_slice(&[42, 44, 46]);
-    ///
-    /// assert_eq!(builder.len(), 3);
-    /// ```
-    #[inline]
-    pub fn extend_from_slice(&mut self, slice: &[T])
-    where
-        T: Clone,
-    {
-        self.reserve(slice.len());
-        // SAFETY: reserve guarantees at least slice.len() spare slots.
-        let dst = unsafe { self.spare_capacity_mut().get_unchecked_mut(..slice.len()) };
-        dst.write_clone_of_slice(slice);
-        self.length += slice.len();
-    }
-
     /// Appends a slice by copying its elements, growing the internal buffer as needed.
     ///
-    /// This does not call [`Clone::clone`]. For types that only implement `Clone`, use
-    /// [`Self::extend_from_slice`].
+    /// This does not call [`Clone::clone`].
     ///
     /// # Example
     ///
     /// ```
     /// use vortex_buffer::BufferMut;
     ///
     /// let mut buffer = BufferMut::from_iter([1, 2]);
-    /// buffer.copy_from_slice(&[3, 4]);
+    /// buffer.extend_from_slice(&[3, 4]);
     /// assert_eq!(buffer.as_slice(), &[1, 2, 3, 4]);
     /// ```
     ///
@@ -735,10 +704,10 @@ impl<T> BufferMut<T> {
     /// struct NotCopy(u32);
     ///
     /// let mut buffer = BufferMut::with_capacity(1);
-    /// buffer.copy_from_slice(&[NotCopy(1)]);
+    /// buffer.extend_from_slice(&[NotCopy(1)]);
     /// ```
     #[inline]
-    pub fn copy_from_slice(&mut self, slice: &[T])
+    pub fn extend_from_slice(&mut self, slice: &[T])
     where
         T: Copy,
     {
@@ -804,7 +773,7 @@ impl<T> BufferMut<T> {
             let capacity = self.capacity();
             let allocator = self.allocation.allocator().clone();
             let mut aligned = Self::with_capacity_aligned_in(capacity, alignment, allocator);
-            aligned.copy_from_slice(&self);
+            aligned.extend_from_slice(&self);
             aligned.capacity = capacity;
             aligned
         }
@@ -840,7 +809,7 @@ impl<T> BufferMut<T> {
     }
 }
 
-impl<T: Clone> Clone for BufferMut<T> {
+impl<T: Copy> Clone for BufferMut<T> {
     fn clone(&self) -> Self {
         let mut buffer = BufferMut::<T>::with_capacity_aligned_in(
             self.capacity(),
@@ -1059,82 +1028,40 @@ impl<T> FromIterator<T> for BufferMut<T> {
 #[cfg(test)]
 mod tests {
     use std::cell::Cell;
-    use std::panic::AssertUnwindSafe;
-    use std::panic::catch_unwind;
 
     use crate::Alignment;
     use crate::BufferMut;
     use crate::buffer_mut;
 
-    #[derive(Clone, Debug, PartialEq)]
-    struct CloneOnly(u32);
-
     #[derive(Copy, Debug, PartialEq)]
     struct CopyWithCloneCounter<'a> {
         value: u32,
         clones: &'a Cell<usize>,
-        panic_at: Option<usize>,
     }
 
     #[allow(clippy::non_canonical_clone_impl)]
     impl Clone for CopyWithCloneCounter<'_> {
         fn clone(&self) -> Self {
             self.clones.set(self.clones.get() + 1);
-            assert_ne!(Some(self.clones.get()), self.panic_at, "clone panicked");
             *self
         }
     }
 
     #[test]
-    fn extend_from_slice_supports_clone_only() {
-        let mut buffer = BufferMut::empty();
-        buffer.push(CloneOnly(1));
-        buffer.extend_from_slice(&[CloneOnly(2), CloneOnly(3)]);
-
-        assert_eq!(
-            buffer.as_slice(),
-            &[CloneOnly(1), CloneOnly(2), CloneOnly(3)]
-        );
-        assert_eq!(buffer.clone().as_slice(), buffer.as_slice());
-    }
-
-    #[test]
-    fn copy_from_slice_skips_clone() {
+    fn extend_from_slice_skips_clone() {
         let clones = Cell::new(0);
         let source = [CopyWithCloneCounter {
             value: 42,
             clones: &clones,
-            panic_at: None,
         }];
         let mut buffer = BufferMut::empty();
         buffer.extend_from_slice(&source);
-        assert_eq!(clones.get(), 1);
-
-        buffer.copy_from_slice(&source);
-        buffer.copy_from_slice(&[]);
-        assert_eq!(clones.get(), 1);
+        buffer.extend_from_slice(&source);
+        buffer.extend_from_slice(&[]);
+        assert_eq!(clones.get(), 0);
         assert_eq!(buffer.as_slice(), &[source[0], source[0]]);
-    }
-
-    #[test]
-    fn extend_from_slice_preserves_buffer_on_clone_panic() {
-        let clones = Cell::new(0);
-        let source = [CopyWithCloneCounter {
-            value: 42,
-            clones: &clones,
-            panic_at: Some(2),
-        }; 2];
-        let mut buffer = BufferMut::empty();
-        buffer.push(source[0]);
-
-        let result = catch_unwind(AssertUnwindSafe(|| buffer.extend_from_slice(&source)));
-        assert!(result.is_err());
-        assert_eq!(clones.get(), 2);
-        assert_eq!(buffer.as_slice(), &source[..1]);
-
-        buffer.copy_from_slice(&source);
-        assert_eq!(clones.get(), 2);
-        assert_eq!(buffer.as_slice(), &[source[0]; 3]);
+        assert_eq!(buffer.clone().as_slice(), buffer.as_slice());
+        assert_eq!(clones.get(), 0);
     }
 
     #[test]