Deriving for `#[repr(packed)]` types

[funsafemath]

It would be nice to be able to derive traits for Copyable packed types by moving out of the reference

#[repr(packed)]
struct Struct<T>(i32, PhantomData<T>);

educe:

#[educe(Clone)]
#[repr(packed)]
struct Struct<T>(i32, PhantomData<T>);
#[automatically_derived]
impl<T> ::core::clone::Clone for Struct<T> {
    #[inline]
    fn clone(&self) -> Self {
        Self(::core::clone::Clone::clone(&self.0), ::core::clone::Clone::clone(&self.1))
    }
    #[inline]
    fn clone_from(&mut self, source: &Self) {
        ::core::clone::Clone::clone_from(&mut self.0, &source.0);
        ::core::clone::Clone::clone_from(&mut self.1, &source.1);
    }
}

core:

#[repr(packed)]
struct Struct<T>(i32, PhantomData<T>);
#[automatically_derived]
impl<T: ::core::clone::Clone + ::core::marker::Copy> ::core::clone::Clone for Struct<T> {
    #[inline]
    fn clone(&self) -> Struct<T> {
        Struct(
            ::core::clone::Clone::clone(&{ self.0 }),
            ::core::clone::Clone::clone(&{ self.1 }),
        )
    }
}

derivative:

#[derivative(Clone)]
#[repr(packed)]
struct Struct<T>(i32, PhantomData<T>);
#[allow(unused_qualifications)]
impl<T> ::std::clone::Clone for Struct<T> {
    fn clone(&self) -> Self {
        match *self {
            Struct(__arg_0, __arg_1) => Struct(__arg_0.clone(), __arg_1.clone()),
        }
    }
}

[magiclen]

This works in 0.8.0.

Debug, Clone, PartialEq, PartialOrd, Ord and Hash now copy each field into a temporary before they read it, like the built-in derives do. Every field that is read must be Copy, and the automatic bound adds that for you. packed(N) is handled the same way.

Your example gets no bound at all, because i32 and PhantomData<T> do not need one:

#[derive(Educe)]
#[educe(Clone)]
#[repr(packed)]
struct Struct<T>(i32, PhantomData<T>);

let a: Struct<String> = Struct(1, PhantomData);
let b = a.clone(); // fine, even though String is not Copy

The built-in derive adds T: Clone + Copy here, so it would not accept Struct<String>.

Two notes. clone_from assigns the new value back instead of cloning in place, because a packed field cannot be borrowed mutably either. Deref and DerefMut did not change: they return a reference to a field, so that field still has to fit the packing.