how do I get a dynamically sized type as bytes?

[TheButlah]

I am attempting to parse some real-world dynamically sized data. Due to the variable-length suffix of this data, I split it into two parts: a fixed size header (ObjectAttrsHeader) and a dynamically sized suffix (AttributesSuffix).

I'd really like to derive IntoBytes for this data, but attempting to add that to ObjectAttributes, but I get an error:

error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
   --> se050/src/attributes.rs:81:24
    |
 81 | ...ytes, IntoBytes, KnownLayout, Immutable, Debug, PartialEq, Eq)]
    |          ^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `ObjectAttributes`, the trait `Sized` is not implemented for `[u8]`
note: required because it appears within the type `ObjectAttributes`
   --> se050/src/attributes.rs:83:12
    |
 83 | pub struct ObjectAttributes {
    |            ^^^^^^^^^^^^^^^^
    = note: required for `ObjectAttributes` to implement `macro_util::__size_of::Sized`
note: required by a bound in `macro_util::__size_of::size_of`
   --> /home/ryan.butler/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/src/util/macro_util.rs:349:29
    |
349 | ...size_of<T: Sized + ?core::marker::Sized>() -> usize {
    |               ^^^^^ required by this bound in `size_of`
    = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
   --> se050/src/attributes.rs:85:21
    |
 85 |     pub policy_set: AttributesSuffix,
    |                     ^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: within `AttributesSuffix`, the trait `Sized` is not implemented for `[u8]`
note: required because it appears within the type `AttributesSuffix`
   --> se050/src/attributes.rs:163:12
    |
163 | pub struct AttributesSuffix([u8]);
    |            ^^^^^^^^^^^^^^^^
    = note: required for `AttributesSuffix` to implement `macro_util::__size_of::Sized`
note: required by a bound in `macro_util::__size_of::size_of`
   --> /home/ryan.butler/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/src/util/macro_util.rs:349:29
    |
349 | ...size_of<T: Sized + ?core::marker::Sized>() -> usize {
    |               ^^^^^ required by this bound in `size_of`

For more information about this error, try `rustc --explain E0277`.

Here is (roughly) the code:

#[derive(TryFromBytes, KnownLayout, Immutable, Debug, PartialEq, Eq)]
#[repr(C, align(1))]
pub struct ObjectAttributes {
    header: ObjectAttrsHeader,
    pub policy_set: AttributesSuffix,
}

#[derive(Debug, thiserror::Error)]
#[error("size mismatch")]
pub struct SizeErr;

impl ObjectAttributes {
    // This exists because we cannot derive(IntoBytes) due to `policy_set` being
    // a DST.
    pub fn as_bytes(&self) -> (&[u8], &[u8]) {
        (self.header.as_bytes(), self.policy_set.as_bytes())
    }

    pub fn len(&self) -> usize {
        let header_len = self.header.as_bytes().len();
        let suffix_len = self.policy_set.as_bytes().len();

        header_len + suffix_len
    }

    pub fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeErr> {
        let header_len = self.header.as_bytes().len();
        let suffix_len = self.policy_set.as_bytes().len();
        if dst.len() != header_len + suffix_len {
            return Err(SizeErr);
        }
        self.header
            .write_to(&mut dst[0..header_len])
            .expect("infallible");
        self.policy_set
            .write_to(&mut dst[header_len..])
            .expect("infallible");

        Ok(())
    }
}

#[derive(
    TryFromBytes, IntoBytes, KnownLayout, Immutable, Debug, PartialEq, Eq, Clone, Copy,
)]
#[repr(C, align(1))]
pub struct ObjectAttrsHeader {
  // ...
}

#[derive(TryFromBytes, IntoBytes, KnownLayout, Immutable, Eq, PartialEq)]
#[repr(C)]
pub struct AttributesSuffix([u8]);

Is there any way to get the full contiguous original slice without needing unsafe? Even with unsafe, I wasn't sure if its sound due to pointer provenance

[hippi345]

Switch the outer struct from repr(C, align(1)) to repr(C, packed). The IntoBytes derive requires a non-generic repr(C) struct to be sized with no padding, which is the error you're hitting, but a packed struct only needs its fields to be IntoBytes, and slice DSTs are fine there. All your fields are align 1 already so the layout doesn't change.

#[derive(TryFromBytes, IntoBytes, KnownLayout, Immutable)]
#[repr(C, packed)]
pub struct ObjectAttributes {
    header: ObjectAttrsHeader,
    pub policy_set: AttributesSuffix,
}

let attrs = ObjectAttributes::try_ref_from_bytes(&raw)?;
assert_eq!(attrs.as_bytes(), &raw[..]);

Compiles and round-trips on 0.8 for me. You'll have to drop the Debug/PartialEq derives (rustc won't derive them through an unsized field in a packed struct), but implementing them over as_bytes() is trivial.