为 slices/`?Sized` 实现 `Deref`

Question

I'm working on a library implementing allocators ( https://github.com/JonathanWoollett-Light/array-allocators ) which can be used in shared memory.

I have a type which currently implements Deref and DerefMut on T: Sized and need it to implement on T: ?Sized to support slices.

This type is TypedLinkedListArrayWrapper :

pub struct TypedLinkedListArrayWrapper<'a, const N: usize, T: ?Sized> {
    pub wrapper: LinkedListArrayWrapper<'a, N>,
    __marker: PhantomData<T>,
}

which implements Deref and DerefMut :

impl<'a, const N: usize, T> Deref for TypedLinkedListArrayWrapper<'a, N, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        unsafe { &*(self.wrapper.deref() as *const [LinkedListArrayBlock]).cast() }
    }
}
impl<'a, const N: usize, T> DerefMut for TypedLinkedListArrayWrapper<'a, N, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *(self.wrapper.deref_mut() as *mut [LinkedListArrayBlock]).cast() }
    }
}

If I change T to be T:?Sized here I get the errors

error[E0277]: the size for values of type `T` cannot be known at compilation time
   --> src/linked_list.rs:166:54
    |
162 | impl<'a, const N: usize, T: ?Sized> Deref for TypedLinkedListArrayWrapper<'a, N, T> {
    |                          - this type parameter needs to be `std::marker::Sized`
...
166 |         unsafe { &*std::ptr::addr_of!(*self.wrapper).cast() }
    |                                                      ^^^^ doesn't have a size known at compile-time
    |
note: required by a bound in `ptr::const_ptr::<impl *const T>::cast`
   --> /home/jonathan/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/ptr/const_ptr.rs:60:23
    |
60  |     pub const fn cast<U>(self) -> *const U {
    |                       ^ required by this bound in `ptr::const_ptr::<impl *const T>::cast`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
    |
162 - impl<'a, const N: usize, T: ?Sized> Deref for TypedLinkedListArrayWrapper<'a, N, T> {
162 + impl<'a, const N: usize, T> Deref for TypedLinkedListArrayWrapper<'a, N, T> {
    |

For more information about this error, try `rustc --explain E0277`.
error: could not compile `array-allocators` due to previous error

---

This is on top of LinkedListArrayWrapper :

pub struct LinkedListArrayWrapper<'a, const N: usize> {
    allocator: &'a LinkedListArrayAllocator<N>,
    index: usize,
    size: usize,
}

which implements Deref and DerefMut :

impl<'a, const N: usize> Deref for LinkedListArrayWrapper<'a, N> {
    type Target = [LinkedListArrayBlock];

    fn deref(&self) -> &Self::Target {
        let allocator = unsafe { &*self.allocator.0.get() };
        &allocator.data[self.index..self.index + self.size]
    }
}
impl<'a, const N: usize> DerefMut for LinkedListArrayWrapper<'a, N> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        let allocator = unsafe { &mut *self.allocator.0.get() };
        &mut allocator.data[self.index..self.index + self.size]
    }
}

where LinkedListArrayBlock is:

pub struct LinkedListArrayBlock {
    size: usize,
    next: Option<usize>,
}

How can I do this?

Answer 1

So I found a solution.

An important topic here relates to https://doc.rust-lang.org/std/ptr/trait.Pointee.html . Unfortunately this is nightly and requires #![feature(ptr_metadata)] .

A solution is to use a custom type for slices to embed the meta data needed for a slice:

pub struct SliceLinkedListArrayWrapper<'a, const N: usize, T> {
    pub wrapper: LinkedListArrayWrapper<'a, N>,
    pub len: usize,
    __marker: PhantomData<T>,
}
impl<'a, const N: usize, T> Deref for SliceLinkedListArrayWrapper<'a, N, T> {
    type Target = [T];

    fn deref(&self) -> &Self::Target {
        unsafe { &*std::ptr::from_raw_parts(std::ptr::addr_of!(*self.wrapper).cast(), self.len) }
    }
}
impl<'a, const N: usize, T> DerefMut for SliceLinkedListArrayWrapper<'a, N, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe {
            &mut *std::ptr::from_raw_parts_mut(
                std::ptr::addr_of_mut!(*self.wrapper).cast(),
                self.len,
            )
        }
    }
}

A more generalized solution is likely possible although may be awkward.

Answer 2

The specific problem here is that .cast() requires the target type to be Sized . The reason can be found in the issue introducing the method:

Like with NonNull::cast , the input pointed type does not need to be Sized but the output pointed type does, because we wouldn't know what appropriate pointer metadata (slice length, trait object vtable, …) to insert.

With that out of the way, I don't understand what you're trying to accomplish. At all. It seems like you're trying to use a slice of LinkedListArrayBlock as backing storage for T ? That seems very dubious and wildly unsound. And even if it weren't you can't cast between fat pointers arbitrarily and have it make sense.