From f6bd083c4ccfc4ce6699b8b4154e3c45c5a27a8c Mon Sep 17 00:00:00 2001 From: Eva Pace Date: Sun, 10 Dec 2023 00:19:24 -0300 Subject: [PATCH] Minor improvements to Vec (#415) --- src/vec/vec-drain.md | 20 ++++++++--------- src/vec/vec-final.md | 43 ++++++++++++++++++------------------ src/vec/vec-insert-remove.md | 5 +++-- src/vec/vec-into-iter.md | 22 +++++++++--------- src/vec/vec-layout.md | 1 - src/vec/vec-raw.md | 32 +++++++++++++-------------- 6 files changed, 59 insertions(+), 64 deletions(-) diff --git a/src/vec/vec-drain.md b/src/vec/vec-drain.md index 7a0e7f81..763c82ae 100644 --- a/src/vec/vec-drain.md +++ b/src/vec/vec-drain.md @@ -93,7 +93,7 @@ impl IntoIterator for Vec { mem::forget(self); IntoIter { - iter: iter, + iter, _buf: buf, } } @@ -135,18 +135,16 @@ impl<'a, T> Drop for Drain<'a, T> { impl Vec { pub fn drain(&mut self) -> Drain { - unsafe { - let iter = RawValIter::new(&self); + let iter = unsafe { RawValIter::new(&self) }; - // this is a mem::forget safety thing. If Drain is forgotten, we just - // leak the whole Vec's contents. Also we need to do this *eventually* - // anyway, so why not do it now? - self.len = 0; + // this is a mem::forget safety thing. If Drain is forgotten, we just + // leak the whole Vec's contents. Also we need to do this *eventually* + // anyway, so why not do it now? + self.len = 0; - Drain { - iter: iter, - vec: PhantomData, - } + Drain { + iter, + vec: PhantomData, } } } diff --git a/src/vec/vec-final.md b/src/vec/vec-final.md index e680e0d6..1f73036d 100644 --- a/src/vec/vec-final.md +++ b/src/vec/vec-final.md @@ -127,7 +127,7 @@ impl Vec { pub fn insert(&mut self, index: usize, elem: T) { assert!(index <= self.len, "index out of bounds"); - if self.cap() == self.len { + if self.len == self.cap() { self.buf.grow(); } @@ -138,14 +138,17 @@ impl Vec { self.len - index, ); ptr::write(self.ptr().add(index), elem); - self.len += 1; } + + self.len += 1; } pub fn remove(&mut self, index: usize) -> T { assert!(index < self.len, "index out of bounds"); + + self.len -= 1; + unsafe { - self.len -= 1; let result = ptr::read(self.ptr().add(index)); ptr::copy( self.ptr().add(index + 1), @@ -157,18 +160,16 @@ impl Vec { } pub fn drain(&mut self) -> Drain { - unsafe { - let iter = RawValIter::new(&self); + let iter = unsafe { RawValIter::new(&self) }; - // this is a mem::forget safety thing. If Drain is forgotten, we just - // leak the whole Vec's contents. Also we need to do this *eventually* - // anyway, so why not do it now? - self.len = 0; + // this is a mem::forget safety thing. If Drain is forgotten, we just + // leak the whole Vec's contents. Also we need to do this *eventually* + // anyway, so why not do it now? + self.len = 0; - Drain { - iter: iter, - vec: PhantomData, - } + Drain { + iter, + vec: PhantomData, } } } @@ -197,15 +198,15 @@ impl IntoIterator for Vec { type Item = T; type IntoIter = IntoIter; fn into_iter(self) -> IntoIter { - unsafe { - let iter = RawValIter::new(&self); - let buf = ptr::read(&self.buf); - mem::forget(self); + let (iter, buf) = unsafe { + (RawValIter::new(&self), ptr::read(&self.buf)) + }; - IntoIter { - iter: iter, - _buf: buf, - } + mem::forget(self); + + IntoIter { + iter, + _buf: buf, } } } diff --git a/src/vec/vec-insert-remove.md b/src/vec/vec-insert-remove.md index 722e20c4..2acee65e 100644 --- a/src/vec/vec-insert-remove.md +++ b/src/vec/vec-insert-remove.md @@ -18,7 +18,7 @@ pub fn insert(&mut self, index: usize, elem: T) { // Note: `<=` because it's valid to insert after everything // which would be equivalent to push. assert!(index <= self.len, "index out of bounds"); - if self.cap == self.len { self.grow(); } + if self.len == self.cap { self.grow(); } unsafe { // ptr::copy(src, dest, len): "copy from src to dest len elems" @@ -28,8 +28,9 @@ pub fn insert(&mut self, index: usize, elem: T) { self.len - index, ); ptr::write(self.ptr.as_ptr().add(index), elem); - self.len += 1; } + + self.len += 1; } ``` diff --git a/src/vec/vec-into-iter.md b/src/vec/vec-into-iter.md index a3a3c8cb..ad22ff98 100644 --- a/src/vec/vec-into-iter.md +++ b/src/vec/vec-into-iter.md @@ -68,18 +68,16 @@ impl IntoIterator for Vec { let cap = vec.cap; let len = vec.len; - unsafe { - IntoIter { - buf: ptr, - cap: cap, - start: ptr.as_ptr(), - end: if cap == 0 { - // can't offset off this pointer, it's not allocated! - ptr.as_ptr() - } else { - ptr.as_ptr().add(len) - }, - } + IntoIter { + buf: ptr, + cap, + start: ptr.as_ptr(), + end: if cap == 0 { + // can't offset off this pointer, it's not allocated! + ptr.as_ptr() + } else { + unsafe { ptr.as_ptr().add(len) } + }, } } } diff --git a/src/vec/vec-layout.md b/src/vec/vec-layout.md index 9129952a..695485f3 100644 --- a/src/vec/vec-layout.md +++ b/src/vec/vec-layout.md @@ -40,7 +40,6 @@ we get the same results as using `Unique`: ```rust use std::ptr::NonNull; -use std::marker::PhantomData; pub struct Vec { ptr: NonNull, diff --git a/src/vec/vec-raw.md b/src/vec/vec-raw.md index 0bca2daf..a251b4af 100644 --- a/src/vec/vec-raw.md +++ b/src/vec/vec-raw.md @@ -131,23 +131,21 @@ impl IntoIterator for Vec { type Item = T; type IntoIter = IntoIter; fn into_iter(self) -> IntoIter { - unsafe { - // need to use ptr::read to unsafely move the buf out since it's - // not Copy, and Vec implements Drop (so we can't destructure it). - let buf = ptr::read(&self.buf); - let len = self.len; - mem::forget(self); - - IntoIter { - start: buf.ptr.as_ptr(), - end: if buf.cap == 0 { - // can't offset off of a pointer unless it's part of an allocation - buf.ptr.as_ptr() - } else { - buf.ptr.as_ptr().add(len) - }, - _buf: buf, - } + // need to use ptr::read to unsafely move the buf out since it's + // not Copy, and Vec implements Drop (so we can't destructure it). + let buf = unsafe { ptr::read(&self.buf) }; + let len = self.len; + mem::forget(self); + + IntoIter { + start: buf.ptr.as_ptr(), + end: if buf.cap == 0 { + // can't offset off of a pointer unless it's part of an allocation + buf.ptr.as_ptr() + } else { + unsafe { buf.ptr.as_ptr().add(len) } + }, + _buf: buf, } } }