assert that T is not a ZST

HeaderVec does not support ZST's, this will give a compiletime error when one tries to do so.
Before it was a Divide by Zero runtime error in the offset calculation.

Remove the ZST code from Drain too (was some remains from std Drain)

Its unlikely that supporting ZST's in HeaderVec makes any sense. Forbiding this altogether
make this clear. When someone comes up with a real use case this may be reviewed.

Author: cehteh

src/drain.rs

@@ -99,24 +99,21 @@ impl<H, T> Drain<'_, H, T> {
             let unyielded_len = this.iter.len();
             let unyielded_ptr = this.iter.as_slice().as_ptr();
 
-            // ZSTs have no identity, so we don't need to move them around.
-            if std::mem::size_of::<T>() != 0 {
-                let start_ptr = source_vec.as_mut_ptr().add(start);
+            let start_ptr = source_vec.as_mut_ptr().add(start);
 
-                // memmove back unyielded elements
-                if unyielded_ptr != start_ptr {
-                    let src = unyielded_ptr;
-                    let dst = start_ptr;
+            // memmove back unyielded elements
+            if unyielded_ptr != start_ptr {
+                let src = unyielded_ptr;
+                let dst = start_ptr;
 
-                    ptr::copy(src, dst, unyielded_len);
-                }
+                ptr::copy(src, dst, unyielded_len);
+            }
 
-                // memmove back untouched tail
-                if tail != (start + unyielded_len) {
-                    let src = source_vec.as_ptr().add(tail);
-                    let dst = start_ptr.add(unyielded_len);
-                    ptr::copy(src, dst, this.tail_len());
-                }
+            // memmove back untouched tail
+            if tail != (start + unyielded_len) {
+                let src = source_vec.as_ptr().add(tail);
+                let dst = start_ptr.add(unyielded_len);
+                ptr::copy(src, dst, this.tail_len());
             }
 
             source_vec.set_len(start + unyielded_len + this.tail_len());
@@ -190,20 +187,6 @@ impl<H, T> Drop for Drain<'_, H, T> {
 
         let mut vec = self.vec;
 
-        // unstable: if T::IS_ZST {  instead we use size_of
-        if mem::size_of::<T>() == 0 {
-            // ZSTs have no identity, so we don't need to move them around, we only need to drop the correct amount.
-            // this can be achieved by manipulating the Vec length instead of moving values out from `iter`.
-            unsafe {
-                let vec = vec.as_mut();
-                let old_len = vec.len();
-                vec.set_len(old_len + drop_len + self.tail_len());
-                vec.truncate(old_len + self.tail_len());
-            }
-
-            return;
-        }
-
         // ensure elements are moved back into their appropriate places, even when drop_in_place panics
         let _guard = DropGuard(self);
 

src/lib.rs

@@ -85,6 +85,7 @@ impl<H, T> HeaderVec<H, T> {
     }
 
     pub fn with_capacity(capacity: usize, head: H) -> Self {
+        const { assert!(mem::size_of::<T>() > 0, "HeaderVec does not support ZST's") };
         // Allocate the initial memory, which is uninitialized.
         let layout = Self::layout(capacity);
         let ptr = unsafe { alloc::alloc::alloc(layout) } as *mut AlignedHeader<H, T>;