Why IntoIter::next() casts a const ptr to mut ptr then back to const ptr

BurtonQin · January 29, 2021, 6:06am

rust-lang/rust/blob/74500b99783d126e330184f0392a78f8b93b73ef/library/alloc/src/vec/into_iter.rs#L122-L130


fn next(&mut self) -> Option<T> {
    if self.ptr as *const _ == self.end {
        None
    } else if mem::size_of::<T>() == 0 {
        // purposefully don't use 'ptr.offset' because for
        // vectors with 0-size elements this would return the
        // same pointer.
        self.ptr = unsafe { arith_offset(self.ptr as *const i8, 1) as *mut T };

Line 129:

self.ptr = unsafe { arith_offset(self.ptr as *const i8, 1) as *mut T };

self.ptr is *const T and arithm_offset() returns *const i8.
Why is the *const i8 cast to *mut T instead of *const T?

kornel · January 29, 2021, 9:42am

It has been changed here:

so I guess as_mut_slice needs *mut T, so the rest of the code had to adjust. But end hasn't been changed to *mut, which is why it's cast back and forth.

BurtonQin · January 29, 2021, 2:26pm

Wow, thx. That is a pretty old commit. as_mut_slice now takes &mut self instead of &self and ptr becomes const ptr again. So the original casting to *mut T becomes unnecessary. Guess developers forget changing it back. Nevertheless, it just looks odd and does not hurt anything.

github.com

rust-lang/rust/blob/c6bc46227ab57a844fc7a9ed3a6c9efb35c725a9/library/alloc/src/vec/into_iter.rs#L73


/// ```
/// let vec = vec!['a', 'b', 'c'];
/// let mut into_iter = vec.into_iter();
/// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
/// into_iter.as_mut_slice()[2] = 'z';
/// assert_eq!(into_iter.next().unwrap(), 'a');
/// assert_eq!(into_iter.next().unwrap(), 'b');
/// assert_eq!(into_iter.next().unwrap(), 'z');
/// ```
#[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")]
pub fn as_mut_slice(&mut self) -> &mut [T] {
    unsafe { &mut *self.as_raw_mut_slice() }
}
/// Returns a reference to the underlying allocator.
#[unstable(feature = "allocator_api", issue = "32838")]
#[inline]
pub fn allocator(&self) -> &A {
    &self.alloc
}

github.com

rust-lang/rust/blob/c6bc46227ab57a844fc7a9ed3a6c9efb35c725a9/library/alloc/src/vec/into_iter.rs#L31


/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoIter<
    T,
    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
> {
    pub(super) buf: NonNull<T>,
    pub(super) phantom: PhantomData<T>,
    pub(super) cap: usize,
    pub(super) alloc: A,
    pub(super) ptr: *const T,
    pub(super) end: *const T,
}
#[stable(feature = "vec_intoiter_debug", since = "1.13.0")]
impl<T: fmt::Debug, A: Allocator> fmt::Debug for IntoIter<T, A> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple("IntoIter").field(&self.as_slice()).finish()
    }
}

system · April 29, 2021, 2:27pm

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.