Re: [PATCH v4 03/16] rust: mem: add `AsRepr` and `AsReprMut`

[Alexandre Courbot]

On Wed Sep 2, 2026 at 1:50 AM JST, Gary Guo wrote:
<...>
> +/// Type that is layout-compatible with a primitive representation.
> +///
> +/// # Safety
> +///
> +/// - `Self` must have the same size and alignment as [`Self::Repr`].
> +/// - `Self` can be [transmutable] to [`Self::Repr`].
> +/// - Neither `Self` nor [`Self::Repr`] contains interior mutability.
> +///
> +/// The above basically says that `&Self` can be transmuted to `&Self::Repr`.
> +///
> +/// [transmutable]: core::mem::transmute
> +pub unsafe trait AsRepr: Sized {
> +    /// Primitive representation of this type.
> +    type Repr;
> +
> +    /// Convert from `&Self` to [`&Self::Repr`](AsRepr::Repr).
> +    #[inline(always)]
> +    fn as_repr(this: &Self) -> &Self::Repr {
> +        // SAFETY: Per safety requirement of the trait.
> +        unsafe { core::mem::transmute(this) }
> +    }
> +
> +    /// Convert from `Self` to [`Self::Repr`].
> +    #[inline(always)]
> +    fn into_repr(this: Self) -> Self::Repr {
> +        // SAFETY: Per safety requirement of the trait.
> +        unsafe { transmute(this) }
> +    }
> +
> +    /// Convert from [`Self::Repr`] to `Self`.
> +    ///
> +    /// # Safety
> +    ///
> +    /// `repr` must be a valid bit pattern of `Self` and satisfy type-specific invariants of it.
> +    ///
> +    /// Alternatively, if `repr` is previously obtained using [`Self::into_repr`], and each
> +    /// `from_repr_unchecked` should corresponds to a unique `into_repr` call, then it is safe to

nit: s/corresponds/correspond

> +    /// call as well (this means that we're undoing a `into_repr` call getting the exact bytes
> +    /// back).
> +    ///
> +    /// This method makes no guarantee if a `into_repr` corresponds to multiple
> +    /// `from_repr_unchecked` (i.e. copies are made), to allow for cases where `Repr` is a pointer

This part doesn't parse for me; maybe it is worth rephrasing?

Something like "No guarantee is made if the result of a `into_repr` is
passed to multiple `from_repr_unchecked`" reads a bit better IMHO.

<...>
> +// SAFETY: `*mut T` has the same size and alignment with `*const c_void`, and thus `*mut T` is
> +// transmutable to `*const c_void`. Neither types contain interior mutability.
> +unsafe impl<T> AsRepr for *mut T {
> +    type Repr = *const c_void;
> +}
> +
> +// SAFETY: `*mut T` is transmutable from `*const c_void`.
> +unsafe impl<T> AsReprMut for *mut T {}
> +
> +// SAFETY: `*const T` has the same size and alignment with `*const c_void`, and is transmutable to
> +// `*const c_void`. Neither types contain interior mutability.
> +unsafe impl<T> AsRepr for *const T {
> +    type Repr = *const c_void;
> +}
> +
> +// SAFETY: `*const T` is transmutable from `*const c_void`.
> +unsafe impl<T> AsReprMut for *const T {}

These pointer impls have no user in the series, should we wait until we
have one to add them?

In any case,

Reviewed-by: Alexandre Courbot <acourbot@xxxxxxxxxx>