Problem

The SchemaRead trait is generic over the lifetime 'de, to which the Reader parameter is also bound in the trait's read function.

pub trait SchemaRead<'de> {
    type Dst;

    fn read(reader: &mut Reader<'de>, dst: &mut MaybeUninit<Self::Dst>) -> ReadResult<()>;
}

This ensures that, when performing zero-copy deserialization (i.e., returning a reference into the Reader's byte buffer), the Reader's buffer must live at least as long as the destination's (dst) lifetime.

This can present a challenge in the implementation of the SchemaRead derive macro.

For example:

#[derive(SchemaRead)]
struct HasRef<'a> {
    name: &'a str
}

The macro must introduce 'de and ensure it outlives 'a.

Now where this can get tricky is when read impls are generated.

// Generated while iterating through the struct's declared fields.
<&'a str as SchemaRead<'de>>::read(
    reader,
    unsafe { &mut *(&raw mut (*dst_ptr).name).cast::<MaybeUninit<_>>() },
)?;

'de extends 'a, but 'a may not necessarily extend 'de (i.e., 'a may not live as long as 'de).

The way that the macro currently gets around this is by rebinding a type's field lifetime to 'de during code generation, which ensures that the bytes read in the read portion are done so as 'de (and as such satisfies the requirement that the read bytes live for 'de).

This is brittle because it only works for reference types (e.g., &'a T). It does not work for types with generic lifetime bounds (e.g., OtherType<'a>) because they are represented as distinct AST nodes. This is not ideal, because in principle, there's no reason we shouldn't be able to zero-copy deserialize nested types containing references.

Summary of changes

This removes the brittle lifetime rebinding done by matching on a single level Type, and instead replaces that functionality with syn's VisitMut, which provides recursive mutable access to the AST nodes that comprise a Type.