Add ZeroCopy marker and SchemaRead support

Author: cpubot

wincode-derive/src/schema_read.rs

@@ -10,7 +10,10 @@ use {
     },
     proc_macro2::TokenStream,
     quote::{format_ident, quote},
-    syn::{parse_quote, DeriveInput, GenericParam, Generics, Type},
+    syn::{
+        parse_quote, punctuated::Punctuated, DeriveInput, GenericParam, Generics, PredicateType,
+        Type, WhereClause, WherePredicate,
+    },
 };
 
 fn impl_struct(
@@ -386,10 +389,48 @@ pub(crate) fn generate(input: DeriveInput) -> Result<TokenStream> {
         }
     };
 
+    // Provide a `ZeroCopy` impl for the type if its `repr` is eligible and all its fields are zero-copy.
+    let zero_copy_impl = match &args.data {
+        Data::Struct(fields) if repr.is_zero_copy_eligible() => {
+            // Ensure all fields are zero-copy.
+            let inner_constraint_predicates = fields.iter().map(|field| {
+                let mut bounds = Punctuated::new();
+                bounds.push(parse_quote!(ZeroCopy));
+                WherePredicate::Type(PredicateType {
+                    // Workaround for https://github.com/rust-lang/rust/issues/48214.
+                    lifetimes: Some(parse_quote!(for<'_wincode_internal>)),
+                    bounded_ty: field.target_resolved(),
+                    colon_token: parse_quote![:],
+                    bounds,
+                })
+            });
+            let (impl_generics, ty_generics, where_clause) = args.generics.split_for_impl();
+            let mut where_clause = where_clause.cloned();
+
+            match &mut where_clause {
+                Some(where_clause) => {
+                    where_clause.predicates.extend(inner_constraint_predicates);
+                }
+                None => {
+                    where_clause = Some(WhereClause {
+                        where_token: parse_quote!(where),
+                        predicates: inner_constraint_predicates.collect(),
+                    });
+                }
+            }
+            quote! {
+                unsafe impl #impl_generics ZeroCopy for #ident #ty_generics #where_clause {}
+            }
+        }
+        _ => quote!(),
+    };
+
     Ok(quote! {
         const _: () = {
             use core::{ptr, mem::{self, MaybeUninit}};
-            use #crate_name::{SchemaRead, ReadResult, TypeMeta, io::Reader, error};
+            use #crate_name::{SchemaRead, ReadResult, TypeMeta, io::Reader, error, ZeroCopy};
+
+            #zero_copy_impl
 
             impl #impl_generics SchemaRead<'de> for #ident #ty_generics #where_clause {
                 type Dst = #src_dst;

wincode/src/error.rs

@@ -44,12 +44,19 @@ pub enum ReadError {
     InvalidCharLead(u8),
     #[error("Custom error: {0}")]
     Custom(&'static str),
+    #[error("Zero-copy read would be unaligned")]
+    UnalignedPointerRead,
 }
 
 pub type Result<T> = core::result::Result<T, Error>;
 pub type WriteResult<T> = core::result::Result<T, WriteError>;
 pub type ReadResult<T> = core::result::Result<T, ReadError>;
 
+#[cold]
+pub const fn unaligned_pointer_read() -> ReadError {
+    ReadError::UnalignedPointerRead
+}
+
 #[cold]
 pub const fn preallocation_size_limit(needed: usize, limit: usize) -> ReadError {
     ReadError::PreallocationSizeLimit { needed, limit }

wincode/src/lib.rs

@@ -198,13 +198,32 @@
 //!   [`containers`] match the layout implied by your `serde` types.
 //! - Length encodings are pluggable via [`SeqLen`](len::SeqLen).
 //!
-//! # Zero copy deserialization
+//! # Zero-copy deserialization
 //!
-//! `wincode` supports zero copy deserialization of contiguous byte slices
-//! (serialized with `Vec<u8>`, `Box<[u8]>`, `[u8; N]`, etc.).
+//! `wincode`'s zero-copy deserialization is built on the following primitives:
+//! - [`u8`]
+//! - [`i8`]
 //!
+//! Within `wincode`, any type that is composed entirely of these primitives is
+//! eligible for zero-copy deserialization.
+//!
+//! Let `Z` be the set of zero-copy types.
+//!
+//! The following higher order types are eligible for zero-copy deserialization:
+//! - `&[Z]`
+//! - `&Z`
+//! - `&[Z; N]`
+//!
+//! Structs deriving [`SchemaWrite`] and [`SchemaRead`] are eligible for zero-copy deserialization
+//! as long as they are composed entirely of the above zero-copy types and are annotated with
+//! `#[repr(transparent)]` or `#[repr(C)]`.
+//! Note that this is **not** true for tuples, as Rust does not currently guarantee tuple layout.
+//!
+//! ## Examples
+//!
+//! ### `&[u8]`
 //! ```
-//! # #[cfg(feature = "derive")] {
+//! # #[cfg(all(feature = "alloc", feature = "derive"))] {
 //! use wincode::{SchemaWrite, SchemaRead};
 //!
 //! # #[derive(Debug, PartialEq, Eq)]
@@ -216,10 +235,59 @@
 //! let bytes: Vec<u8> = vec![1, 2, 3, 4, 5];
 //! let byte_ref = ByteRef { bytes: &bytes };
 //! let serialized = wincode::serialize(&byte_ref).unwrap();
-//! let deserialized = wincode::deserialize(&serialized).unwrap();
+//! let deserialized: ByteRef<'_> = wincode::deserialize(&serialized).unwrap();
 //! assert_eq!(byte_ref, deserialized);
 //! # }  
 //! ```
+//!
+//! ### struct newtype
+//! ```
+//! # #[cfg(all(feature = "alloc", feature = "derive"))] {
+//! # use rand::random;
+//! # use std::array;
+//! use wincode::{SchemaWrite, SchemaRead};
+//!
+//! # #[derive(Debug, PartialEq, Eq)]
+//! #[derive(SchemaWrite, SchemaRead)]
+//! #[repr(transparent)]
+//! struct Signature([u8; 64]);
+//!
+//! # #[derive(Debug, PartialEq, Eq)]
+//! #[derive(SchemaWrite, SchemaRead)]
+//! struct Data<'a> {
+//!     signature: &'a Signature,
+//!     data: &'a [u8],
+//! }
+//!
+//! let signature = Signature(array::from_fn(|_| random()));
+//! let data = Data {
+//!     signature: &signature,
+//!     data: &[1, 2, 3, 4, 5],
+//! };
+//! let serialized = wincode::serialize(&data).unwrap();
+//! let deserialized: Data<'_> = wincode::deserialize(&serialized).unwrap();
+//! assert_eq!(data, deserialized);
+//! # }
+//! ```
+//!
+//! ### `&[u8; N]`
+//! ```
+//! # #[cfg(all(feature = "alloc", feature = "derive"))] {
+//! use wincode::{SchemaWrite, SchemaRead};
+//!
+//! # #[derive(Debug, PartialEq, Eq)]
+//! #[derive(SchemaWrite, SchemaRead)]
+//! struct HeaderRef<'a> {
+//!     magic: &'a [u8; 7],
+//! }
+//!
+//! let header = HeaderRef { magic: b"W1NC0D3" };
+//! let serialized = wincode::serialize(&header).unwrap();
+//! let deserialized: HeaderRef<'_> = wincode::deserialize(&serialized).unwrap();
+//! assert_eq!(header, deserialized);
+//! # }
+//! ```
+//!
 //! # Derive attributes
 //!
 //! ## Top level

wincode/src/schema/containers.rs

@@ -87,7 +87,7 @@ use {
         error::{ReadResult, WriteResult},
         io::{Reader, Writer},
         schema::{SchemaRead, SchemaWrite},
-        TypeMeta,
+        TypeMeta, ZeroCopy,
     },
     core::{marker::PhantomData, mem::MaybeUninit, ptr},
 };
@@ -262,6 +262,13 @@ pub struct Elem<T>(PhantomData<T>);
 /// ```
 pub struct Pod<T: Copy + 'static>(PhantomData<T>);
 
+// SAFETY:
+// - By using `Pod`, user asserts that the type is zero-copy, given the contract of Pod:
+//   - The type's in‑memory representation is exactly its serialized bytes.
+//   - It can be safely initialized by memcpy (no validation, no endianness/layout work).
+//   - Does not contain references or pointers.
+unsafe impl<T> ZeroCopy for Pod<T> where T: Copy + 'static {}
+
 impl<T> SchemaWrite for Pod<T>
 where
     T: Copy + 'static,