memorypack-derive 2.0.0

Derive macros for memorypack serialization
Documentation
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{Data, DataStruct, Field, Fields, Member};

use crate::generation::helpers::{
    DeserializationMode,
    generate_field_deserialize_value,
    generate_field_serialize,
    get_field_order,
    should_skip_field
};
const MAX_MEMBER_COUNT: usize = 249;
const MAX_INLINE_LENGTH: usize = 127;
const REFERENCE_HEADER: u8 = 250;

struct FieldLayout<'a> {
    field: &'a Field,
    member: Member,
    binding: syn::Ident,
    order: usize,
    skipped: bool
}

pub fn generate_version_tolerant_serialize(data: &Data) -> TokenStream {
    generate_serialize(data, false)
}

pub fn generate_version_tolerant_deserialize(data: &Data) -> TokenStream {
    generate_deserialize(data, false)
}

pub fn generate_serialize(data: &Data, circular: bool) -> TokenStream {
    let reference_header = serialize_reference(circular);
    let reference_id = circular.then(|| {
        quote! {
            memorypack::varint::write_varint(writer, i64::from(reference_id))?;
        }
    });
    serialize_members(data, &reference_header, reference_id.as_ref())
}

pub fn generate_graph_serialize(data: &Data) -> TokenStream {
    let reference_id = quote! {
        memorypack::varint::write_varint(writer, i64::from(reference_id))?;
    };

    serialize_members(data, &quote! {}, Some(&reference_id))
}

pub fn generate_graph_deserialize(data: &Data) -> TokenStream {
    let Data::Struct(structure) = data else {
        return quote! { compile_error!("MemoryPackable requires a struct"); };
    };

    deserialize_members(structure, false)
}

pub fn generate_deserialize(data: &Data, circular: bool) -> TokenStream {
    let Data::Struct(structure) = data else {
        return quote! { compile_error!("MemoryPackable requires a struct"); };
    };

    let reference_header = deserialize_reference(circular);
    let members = deserialize_members(structure, circular);

    quote! {
        let header = reader.read_u8()?;
        #reference_header

        if usize::from(header) > #MAX_MEMBER_COUNT {
            return Err(memorypack::MemoryPackError::InvalidLength(i32::from(header)));
        }

        let mut field_lengths = [0_usize; #MAX_MEMBER_COUNT];
        let lengths = &mut field_lengths[..usize::from(header)];

        for length in lengths.iter_mut() {
            *length = usize::try_from(memorypack::varint::read_varint(reader)?)
                .map_err(|_| memorypack::MemoryPackError::UnexpectedEndOfBuffer)?;
        }

        #members
    }
}

fn field_layout(structure: &DataStruct) -> Vec<FieldLayout<'_>> {
    structure
        .fields
        .iter()
        .enumerate()
        .map(|(index, field)| {
            let member = field
                .ident
                .clone()
                .map_or_else(|| Member::Unnamed(index.into()), Member::Named);

            FieldLayout {
                field,
                member,
                binding: format_ident!("field_{index}"),
                order: get_field_order(field).unwrap_or(index),
                skipped: should_skip_field(field)
            }
        })
        .collect()
}

fn member_count(fields: &[FieldLayout]) -> usize {
    fields
        .iter()
        .filter(|field| !field.skipped)
        .map(|field| field.order + 1)
        .max()
        .unwrap_or(0)
}

fn serialize_field(field: &FieldLayout) -> TokenStream {
    let FieldLayout { member, order, .. } = field;
    let serialize = generate_field_serialize(field.field, &quote! { &self.#member });

    quote! {
        let start = writer.buffer.len();
        #serialize
        field_lengths[#order] = writer.buffer.len() - start;
    }
}

fn deserialize_field(field: &FieldLayout) -> TokenStream {
    let FieldLayout { binding, order, .. } = field;
    let deserialize = generate_field_deserialize_value(field.field, DeserializationMode::Input);

    quote! {
        #order if length > 0 => {
            #binding = #deserialize;
        }
    }
}

fn construct_value(structure: &DataStruct, fields: &[FieldLayout]) -> TokenStream {
    let bindings = fields.iter().map(|field| &field.binding);

    match &structure.fields {
        Fields::Named(_) => {
            let members = fields.iter().map(|field| &field.member);

            quote! { Self { #(#members: #bindings),* } }
        }
        Fields::Unnamed(_) => quote! { Self(#(#bindings),*) },
        Fields::Unit => quote! { Self }
    }
}

fn serialize_reference(circular: bool) -> TokenStream {
    if !circular {
        return quote! {};
    }

    quote! {
        let (existing, reference_id) = writer.optional_state
            .get_or_insert_with(memorypack::MemoryPackWriterOptionalState::new)
            .get_or_add_reference(self);

        if existing {
            writer.write_object_reference_id(reference_id)?;

            return Ok(());
        }
    }
}

fn deserialize_reference(circular: bool) -> TokenStream {
    if !circular {
        return quote! {};
    }

    quote! {
        if header == #REFERENCE_HEADER {
            let reference_id = memorypack::varint::read_varint(reader)? as u32;

            return reader.optional_state
                .get_or_insert_with(memorypack::MemoryPackReaderOptionalState::new)
                .get_object_reference(reference_id);
        }
    }
}

fn serialize_members(
    data: &Data,
    reference_header: &TokenStream,
    reference_id: Option<&TokenStream>
) -> TokenStream {
    let Data::Struct(structure) = data else {
        return quote! { compile_error!("MemoryPackable requires a struct"); };
    };

    let fields = field_layout(structure);
    let member_count = member_count(&fields);

    if member_count > MAX_MEMBER_COUNT {
        return quote! { compile_error!("MemoryPack objects support at most 249 members"); };
    }

    let writes = fields
        .iter()
        .filter(|field| !field.skipped)
        .map(serialize_field);

    quote! {
        #reference_header
        writer.write_u8(#member_count as u8)?;

        let lengths_position = writer.buffer.len();
        writer.buffer.resize(lengths_position + #member_count, 0);
        #reference_id
        let mut field_lengths = [0_usize; #member_count];
        #(#writes)*

        if field_lengths.iter().all(|&length| length <= #MAX_INLINE_LENGTH) {
            for (index, length) in field_lengths.into_iter().enumerate() {
                writer.buffer[lengths_position + index] = length as u8;
            }
        } else {
            let mut length_writer = memorypack::MemoryPackWriter::new();

            for length in field_lengths {
                memorypack::varint::write_varint(&mut length_writer, length as i64)?;
            }

            writer.buffer.splice(lengths_position..lengths_position + #member_count, length_writer.buffer);
        }
    }
}

fn deserialize_members(structure: &DataStruct, circular: bool) -> TokenStream {
    let fields = field_layout(structure);
    let bindings = fields
        .iter()
        .map(|field| &field.binding)
        .collect::<Vec<_>>();
    let reads = fields
        .iter()
        .filter(|field| !field.skipped)
        .map(deserialize_field);
    let construct = construct_value(structure, &fields);
    let reference_register = circular.then(|| {
        quote! {
            let reference_id = memorypack::varint::read_varint(reader)? as u32;
            let placeholder = #construct;
            reader.optional_state.get_or_insert_with(memorypack::MemoryPackReaderOptionalState::new)
                .add_object_reference(reference_id, placeholder)?;
            #(let mut #bindings = Default::default();)*
        }
    });
    let reference_update = circular.then(|| {
        quote! {
            reader.optional_state.get_or_insert_with(memorypack::MemoryPackReaderOptionalState::new)
                .update_object_reference(reference_id, result.clone())?;
        }
    });

    quote! {
        #(let mut #bindings = Default::default();)*
        #reference_register

        for (order, &length) in lengths.iter().enumerate() {
            let start = reader.position();

            match order {
                #(#reads)*
                _ => {}
            }

            let consumed = (reader.position() - start) as usize;
            reader.skip(length.checked_sub(consumed)
                .ok_or(memorypack::MemoryPackError::UnexpectedEndOfBuffer)?)?;
        }

        let result = #construct;
        #reference_update

        Ok(result)
    }
}