layline-codegen 0.5.0

Rust source generation for layline.
Documentation
//! Optional fields.

use proc_macro2::Literal;
use quote::{format_ident, quote};

use super::body::{Bind, Item, Own, Walk, needs_clone};
use super::cursor::read_layout;
use super::table::{Row, deferred_type, span_of_kind};
use super::value::{value_read, value_write};
use crate::root::Prelude;
use crate::walk::tokens::ident;
use crate::walk::{block_field, emit_message_field, hidden_block, kind_ty, row};
use crate::{Error, Kind, Presence, Segment};

impl Walk<'_> {
    pub(super) fn opt(
        &mut self,
        item: &mut Item<'_>,
        own: Own,
        seg: &Segment,
        last: bool,
    ) -> Result<(), Error> {
        let Prelude { some, none, option, .. } = self.root.prelude();
        let (root, owner) = (self.root, self.owner);
        let Segment::Opt { when, field: f } = seg else { unreachable!("just matched") };
        let ident = ident(&f.name);
        let ty = kind_ty(&f.kind, root);
        let opt_ty = quote!(#option<#ty>);
        self.public_fields.extend(emit_message_field(f, true, root, &self.skip));
        self.binds.push(Bind { name: ident.clone(), ty: opt_ty, value: quote!(#ident) });

        let present = match when {
            Presence::Mask { field: flag, mask } | Presence::MaskClear { field: flag, mask } => {
                let read = self.env.get(owner, "#[when]", flag)?;
                let bit = Literal::i64_unsuffixed(*mask as i64);
                if matches!(when, Presence::Mask { .. }) {
                    quote!(((#read) & #bit) != 0)
                } else {
                    quote!(((#read) & #bit) == 0)
                }
            }
            Presence::Flag { field: flag } => self.env.get_flag(owner, "#[when]", flag)?,
            Presence::FlagClear { field: flag } => {
                let read = self.env.get_flag(owner, "#[when]", flag)?;
                quote!(!(#read))
            }
            Presence::Remaining => {
                let need = Literal::usize_unsuffixed(f.kind.width() as usize / 8);
                quote!(__body.len().saturating_sub(__at) >= #need)
            }
            Presence::Bit => {
                return Err(Error::Refused(format!(
                    "{owner}: `{}` uses an inline presence bit, but this message is byte-addressed. \
                     Make the message bit-addressed, or absent the field on a flag",
                    f.name
                )));
            }
        };
        let mut row = Row::new(&f.name, span_of_kind(&f.kind))
            .decoded_by(deferred_type(&f.kind))
            .when(match when.tests() {
                Some((flag, mask, true)) => row::Presence::Flag { field: flag.into(), mask },
                Some((flag, mask, false)) => row::Presence::Clear { field: flag.into(), mask },
                None if matches!(when, Presence::Remaining) => row::Presence::Remaining,
                None => row::Presence::Bit,
            });

        let fixed = !matches!(f.kind, Kind::Var { .. } | Kind::Msg { .. } | Kind::Text { .. });
        let (parse_one, write_one) = if fixed {
            let bits = f.kind.width();
            if bits == 0 || !bits.is_multiple_of(8) {
                return Err(Error::Refused(format!(
                    "{owner}: optional field `{}` is {bits} bits, not whole bytes. \
                     Wrap it in a `#[derive(Layout)]` type and make that optional",
                    f.name
                )));
            }
            let sub = format_ident!("__{}Opt{}", owner, item.opt_n);
            item.opt_n += 1;
            let len = Literal::usize_unsuffixed((bits / 8) as usize);
            item.items.extend(hidden_block(root, &sub, &len, &self.endian, block_field(f, root)));
            row = row.table(&sub, core::slice::from_ref(f), bits, item.endian);
            let take = if needs_clone(&f.kind) { quote!(__v.clone()) } else { quote!(*__v) };
            let read = read_layout(&format_ident!("__o"), &sub, &len, root);
            (
                quote! {
                    #read
                    #some(__o.#ident)
                },
                quote! { out.push(&#sub { #ident: #take }.encode())?; },
            )
        } else {
            let ctx = self.with_ctx(&f.kind, own)?;
            let inner = value_read(&self.env, owner, &f.name, &f.kind, ctx.as_ref(), root)?;
            (
                quote! { #inner #some(#ident) },
                value_write(&f.name, &f.kind, quote!(__v), quote!(__v), ctx.as_ref(), root)?,
            )
        };
        self.rows.push(row);

        self.parse_steps.extend(quote! {
            let #ident = if #present {
                #parse_one
            } else {
                #none
            };
        });
        let held = own.by_ref(&f.name);
        self.byte_steps.extend(quote! {
            if let #some(__v) = #held {
                #write_one
            }
        });

        self.held_message(item, &f.name, &f.kind, last)
    }
}