use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
use syn::{Error, Ident, Type};
use crate::model::{FieldCtx, FieldParts, VariantCtx, VariantParts};
use crate::util::*;
pub(crate) fn vec_drop_stmt(fname: &Ident, elem: &TokenStream, nullable: bool) -> TokenStream {
let free = quote! {
unsafe { ::bstack_raii::BStackVec::<#elem, __A>::from_desc(__on_disk.#fname, allocator) }
.bstack_drop()?;
};
if nullable {
quote! { { if !__on_disk.#fname.data_off.is_null() { #free } } }
} else {
quote! { { #free } }
}
}
pub(crate) fn vec_accessor(
vis: &syn::Visibility,
fname: &Ident,
elem: &TokenStream,
on_disk: &TokenStream,
nullable: bool,
) -> TokenStream {
let getter = format_ident!("get_{}", fname);
let field = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk, #fname) as u64
)?);
if nullable {
quote! {
#vis fn #getter<'__v, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__v __A,
) -> ::std::io::Result<
::core::option::Option<::bstack_raii::BStackVec<'__v, #elem, __A>>
> {
unsafe { ::bstack_raii::BStackVec::from_field_opt(::bstack_raii::NonNullOffset::from_field(#field)?, allocator) }
}
}
} else {
quote! {
#vis fn #getter<'__v, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__v __A,
) -> ::std::io::Result<::bstack_raii::BStackVec<'__v, #elem, __A>> {
unsafe { ::bstack_raii::BStackVec::from_field(::bstack_raii::NonNullOffset::from_field(#field)?, allocator) }
}
}
}
}
pub(crate) fn vec_ctor(
fname: &Ident,
vinfo: &VecInfo,
nullable: bool,
) -> (TokenStream, TokenStream, TokenStream) {
let elem = &vinfo.elem;
let base_param: TokenStream = if vinfo.is_string {
quote!(&str)
} else {
quote!(&[#elem])
};
let data_of = |b: TokenStream| -> TokenStream {
if vinfo.is_string {
quote!(#b.as_bytes())
} else {
b
}
};
let prep = if nullable {
let some_data = data_of(quote!(__d));
quote! {
let #fname: ::bstack_raii::VecDesc = match #fname {
::core::option::Option::Some(__d) =>
::bstack_raii::BStackVec::<#elem, __A>::from_slice(allocator, #some_data)?
.descriptor(),
::core::option::Option::None => ::core::default::Default::default(),
};
}
} else {
let data = data_of(quote!(#fname));
quote! {
let #fname: ::bstack_raii::VecDesc =
::bstack_raii::BStackVec::<#elem, __A>::from_slice(allocator, #data)?
.descriptor();
}
};
let param = if nullable {
quote!(#fname: ::core::option::Option<#base_param>,)
} else {
quote!(#fname: #base_param,)
};
(param, prep, quote!(#fname,))
}
pub(crate) fn vec_move(
cap: &Ident,
elem: &TokenStream,
nullable: bool,
) -> (TokenStream, TokenStream) {
let ty = quote!(::bstack_raii::BStackVec<'__mv, #elem, __A>);
let build = quote!(unsafe { ::bstack_raii::BStackVec::from_desc(#cap, __alloc) });
wrap_vec_move(ty, build, cap, nullable)
}
pub(crate) fn vec_clone_stmt(fname: &Ident, kind: Kind, elem: &TokenStream) -> TokenStream {
let clone_expr = match kind {
Kind::Pod => quote! {
unsafe { ::bstack_raii::BStackVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_data_into(__plan)?
},
Kind::Owned => quote! {
unsafe { ::bstack_raii::BStackBlockVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan, |__er, __p| {
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(__er) }
.__bstack_clone_into(allocator, __p)
})?
},
Kind::Strong => quote! {
unsafe { ::bstack_raii::BStackStrongVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan)?
},
Kind::Weak => quote! {
unsafe { ::bstack_raii::BStackWeakVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan)?
},
Kind::Ref => quote! {
unsafe { ::bstack_raii::BStackRefVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan)?
},
Kind::Embed => quote!(unreachable!()),
};
quote! {
{
let __srcdesc: ::bstack_raii::VecDesc = __od.#fname;
if !__srcdesc.data_off.is_null() {
let __newdesc: ::bstack_raii::VecDesc = #clone_expr;
__od.#fname = __newdesc;
}
}
}
}
pub(crate) fn wrap_vec_move(
ty: TokenStream,
build: TokenStream,
cap: &Ident,
nullable: bool,
) -> (TokenStream, TokenStream) {
if nullable {
(
quote!(::core::option::Option<#ty>),
quote! {
if !#cap.data_off.is_null() {
::core::option::Option::Some(#build)
} else {
::core::option::Option::None
}
},
)
} else {
(ty, build)
}
}
pub(crate) fn block_vec_drop_stmt(
fname: &Ident,
vec_ty: TokenStream,
elem: &TokenStream,
nullable: bool,
) -> TokenStream {
let free = quote! {
unsafe { ::bstack_raii::#vec_ty::<#elem, __A>::from_desc(__on_disk.#fname, allocator) }
.bstack_drop()?;
};
if nullable {
quote! { { if !__on_disk.#fname.data_off.is_null() { #free } } }
} else {
quote! { { #free } }
}
}
pub(crate) fn block_vec_accessor(
vis: &syn::Visibility,
fname: &Ident,
elem: &TokenStream,
on_disk: &TokenStream,
vec_ty: TokenStream,
nullable: bool,
) -> TokenStream {
let getter = format_ident!("get_{}", fname);
let field = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk, #fname) as u64
)?);
if nullable {
quote! {
#vis fn #getter<'__v, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__v __A,
) -> ::std::io::Result<
::core::option::Option<::bstack_raii::#vec_ty<'__v, #elem, __A>>
> {
unsafe { ::bstack_raii::#vec_ty::from_field_opt(::bstack_raii::NonNullOffset::from_field(#field)?, allocator) }
}
}
} else {
quote! {
#vis fn #getter<'__v, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__v __A,
) -> ::std::io::Result<::bstack_raii::#vec_ty<'__v, #elem, __A>> {
unsafe { ::bstack_raii::#vec_ty::from_field(::bstack_raii::NonNullOffset::from_field(#field)?, allocator) }
}
}
}
}
pub(crate) fn block_vec_ctor(
fname: &Ident,
elem: &TokenStream,
vec_ty: TokenStream,
handle_ty: TokenStream,
nullable: bool,
owns: bool,
) -> (TokenStream, TokenStream, TokenStream) {
let build = |src: TokenStream| -> TokenStream {
if owns {
quote! {
match ::bstack_raii::#vec_ty::<#elem, __A>::from_handles(allocator, #src) {
::core::result::Result::Ok(__v) => __v.descriptor(),
::core::result::Result::Err(__e) => {
::core::mem::drop(__e.value);
return ::core::result::Result::Err(::core::convert::Into::into(__e.source));
}
}
}
} else {
quote! {
::bstack_raii::#vec_ty::<#elem, __A>::from_handles(allocator, #src)?.descriptor()
}
}
};
if nullable {
let some_build = build(quote!(__v));
(
quote!(#fname: ::core::option::Option<::std::vec::Vec<#handle_ty>>,),
quote! {
let #fname: ::bstack_raii::VecDesc = match #fname {
::core::option::Option::Some(__v) => #some_build,
::core::option::Option::None => ::core::default::Default::default(),
};
},
quote!(#fname,),
)
} else {
let build = build(quote!(#fname));
(
quote!(#fname: ::std::vec::Vec<#handle_ty>,),
quote! {
let #fname: ::bstack_raii::VecDesc = #build;
},
quote!(#fname,),
)
}
}
pub(crate) fn block_vec_move(
cap: &Ident,
elem: &TokenStream,
vec_ty: TokenStream,
nullable: bool,
) -> (TokenStream, TokenStream) {
let ty = quote!(::bstack_raii::#vec_ty<'__mv, #elem, __A>);
let build = quote!(unsafe { ::bstack_raii::#vec_ty::from_desc(#cap, __alloc) });
wrap_vec_move(ty, build, cap, nullable)
}
pub(crate) fn foreign_elem_drop(kind: Kind, ftarget: &Type) -> TokenStream {
let helper = match kind {
Kind::Owned => quote!(<#ftarget as ::bstack_raii::BStackBlock>::foreign_drop),
Kind::Strong => {
quote!(<#ftarget as ::bstack_raii::BStackShared>::foreign_drop_strong)
}
Kind::Weak => quote!(<#ftarget as ::bstack_raii::BStackWeakable>::foreign_drop_weak),
_ => return quote!(),
};
quote! {
let __off = __fp.offset().get();
if __off != 0 {
let __fid = __fp.file_id();
if __fid == 0 {
unsafe { #helper::<_>(allocator, ::bstack_raii::NonNullOffset::from_field(__off)?)?; }
} else if let ::core::option::Option::Some(__id) =
::bstack_raii::registry::FileId::from_u64(__fid)
{
if let ::core::option::Option::Some(__host) =
::bstack_raii::registry::host_arc(__id)
{
let __adapter = ::bstack_raii::ForeignHostAllocator::new(__host, __id);
unsafe { #helper::<_>(&__adapter, ::bstack_raii::NonNullOffset::from_field(__off)?)?; }
}
}
}
}
}
pub(crate) fn foreign_elem_clone(kind: Kind, ftarget: &Type) -> TokenStream {
let od_size = quote! {
::core::mem::size_of::<<#ftarget as ::bstack_raii::BStackBlock>::OnDisk>() as u64
};
let not_attached = |ann: &str| {
let msg = format!("cannot clone `{ann} Foreign<T>` element: target file not attached");
quote! {
::std::io::Error::new(::std::io::ErrorKind::NotFound, #msg)
}
};
let malformed = quote! {
return ::std::result::Result::Err(::std::io::Error::new(
::std::io::ErrorKind::InvalidData, "cannot clone `Foreign<T>`: malformed file id"));
};
match kind {
Kind::Owned => {
let err = not_attached("#[bstack_owned]");
quote! {
let __newfp: ::bstack_raii::WidePtr = {
let __off = __fp.offset().get();
if __off == 0 {
__fp
} else {
let __fid = __fp.file_id();
if __fid == 0 {
let __child = unsafe { <#ftarget as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__off, #od_size)) };
let __new = __child.__bstack_clone_into(allocator, __plan)?;
::bstack_raii::WidePtr::from_raw(0, __fp.type_index(), __new.start())
} else if __plan.is_measuring() {
__fp
} else if let ::core::option::Option::Some(__id) =
::bstack_raii::registry::FileId::from_u64(__fid)
{
let __host = ::bstack_raii::registry::host_arc(__id)
.ok_or_else(|| #err)?;
let __adapter =
::bstack_raii::ForeignHostAllocator::new(__host, __id);
let __new_off = unsafe {
<#ftarget as ::bstack_raii::BStackBlock>::foreign_clone::<_>(&__adapter, ::bstack_raii::NonNullOffset::from_field(__off)?)? };
::bstack_raii::WidePtr::from_raw(__fid, __fp.type_index(), __new_off)
} else {
#malformed
}
}
};
}
}
Kind::Strong => {
let err = not_attached("#[bstack_strong]");
quote! {
let __newfp: ::bstack_raii::WidePtr = {
let __off = __fp.offset().get();
if __off != 0 {
let __fid = __fp.file_id();
if __fid == 0 {
let __data = unsafe { ::bstack_raii::BStackRef::<#ftarget>::from_range(
::bstack_raii::BStackRange::new(__off, #od_size)) };
__plan.bump_strong(__data, allocator)?;
} else if __plan.is_measuring() {
} else if let ::core::option::Option::Some(__id) =
::bstack_raii::registry::FileId::from_u64(__fid)
{
let __host = ::bstack_raii::registry::host_arc(__id)
.ok_or_else(|| #err)?;
let __adapter =
::bstack_raii::ForeignHostAllocator::new(__host, __id);
unsafe { <#ftarget as ::bstack_raii::BStackShared>::foreign_clone_strong::<_>(&__adapter, ::bstack_raii::NonNullOffset::from_field(__off)?)?; }
} else {
#malformed
}
}
__fp
};
}
}
Kind::Weak => {
let err = not_attached("#[bstack_weak]");
quote! {
let __newfp: ::bstack_raii::WidePtr = {
let __off = __fp.offset().get();
if __off != 0 {
let __fid = __fp.file_id();
if __fid == 0 {
__plan.bump_weak(__off)?;
} else if __plan.is_measuring() {
} else if let ::core::option::Option::Some(__id) =
::bstack_raii::registry::FileId::from_u64(__fid)
{
let __host = ::bstack_raii::registry::host_arc(__id)
.ok_or_else(|| #err)?;
let __adapter =
::bstack_raii::ForeignHostAllocator::new(__host, __id);
unsafe { <#ftarget as ::bstack_raii::BStackWeakable>::foreign_clone_weak::<_>(&__adapter, ::bstack_raii::NonNullOffset::from_field(__off)?)?; }
} else {
#malformed
}
}
__fp
};
}
}
_ => quote! { let __newfp: ::bstack_raii::WidePtr = __fp; },
}
}
pub(crate) fn try_clone_in_impl(
impl_g: &impl quote::ToTokens,
name: &Ident,
ty_g: &impl quote::ToTokens,
where_g: &impl quote::ToTokens,
) -> TokenStream {
quote! {
impl #impl_g ::bstack_raii::TryCloneIn for #name #ty_g #where_g {
fn try_clone_in<__A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &__A,
) -> ::std::io::Result<::bstack_raii::BStackOwned<Self>> {
use ::bstack_raii::BStackBlock as _;
let __dst = ::bstack_raii::ClonePlan::run_clone(allocator, |__plan| {
self.__bstack_clone_into(allocator, __plan)
})?;
::std::result::Result::Ok(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <Self as ::bstack_raii::BStackBlock>::from_range(__dst) },
)
})
}
}
}
}
pub(crate) fn accessor(
vis: &syn::Visibility,
fname: &Ident,
inner_ty: &Type,
on_disk: &TokenStream,
kind: Kind,
nullable: bool,
) -> TokenStream {
let getter = format_ident!("get_{}", fname);
if kind == Kind::Weak {
return quote! {
#vis fn #getter<'__u, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__u __A,
) -> ::std::io::Result<
::core::option::Option<::bstack_raii::BStackRc<'__u, #inner_ty, __A>>
> {
let __field = ::bstack_raii::checked_field_offset(self.0.start(), ::core::mem::offset_of!(#on_disk, #fname) as u64)?;
unsafe { ::bstack_raii::BStackWeakable::upgrade_weak_field(allocator, ::bstack_raii::NonNullOffset::from_field(__field)?) }
}
};
}
let read = quote! {
let mut __buf = ::std::vec![0u8; ::core::mem::size_of::<#on_disk>()];
let __r = unsafe { ::bstack_raii::BStackRef::<Self>::from_range(self.0) };
let __od: #on_disk = *__r.read_on_disk(stack, &mut __buf)?;
};
if kind == Kind::Pod {
return quote! {
#vis fn #getter(&self, stack: &::bstack_raii::BStack) -> ::std::io::Result<#inner_ty> {
#read
::std::result::Result::Ok(__od.#fname)
}
};
}
let resolve = quote! {
unsafe { <#inner_ty as ::bstack_raii::BStackBlock>::from_range(::bstack_raii::BStackRange::new(
__od.#fname,
::core::mem::size_of::<<#inner_ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64,
)) }
};
if nullable {
quote! {
#vis fn #getter(
&self,
stack: &::bstack_raii::BStack,
) -> ::std::io::Result<::core::option::Option<#inner_ty>> {
#read
if __od.#fname == 0 {
::std::result::Result::Ok(::core::option::Option::None)
} else {
::std::result::Result::Ok(::core::option::Option::Some(#resolve))
}
}
}
} else {
quote! {
#vis fn #getter(&self, stack: &::bstack_raii::BStack) -> ::std::io::Result<#inner_ty> {
#read
::std::result::Result::Ok(#resolve)
}
}
}
}
pub(crate) fn raw_slice_accessor(
vis: &syn::Visibility,
fname: &Ident,
inner_ty: &Type,
on_disk: &TokenStream,
kind: Kind,
) -> TokenStream {
let raw = format_ident!("raw_{}_slice", fname);
let len = match kind {
Kind::Pod => quote!(::core::mem::size_of::<#inner_ty>() as u64),
Kind::Embed => {
quote!(::core::mem::size_of::<<#inner_ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64)
}
Kind::Owned | Kind::Strong | Kind::Weak | Kind::Ref => quote!(8u64),
};
quote! {
#vis unsafe fn #raw<'__s>(
&self,
stack: &'__s ::bstack_raii::BStack,
) -> ::std::io::Result<::bstack_raii::BStackSlice<'__s>> {
let __off = ::bstack_raii::checked_field_offset(self.0.start(), ::core::mem::offset_of!(#on_disk, #fname) as u64)?;
::std::result::Result::Ok(unsafe {
::bstack_raii::BStackSlice::from_raw_range(
stack,
::bstack_raii::BStackRange::new(__off, #len),
)
})
}
}
}
pub(crate) fn set_accessor(
vis: &syn::Visibility,
fname: &Ident,
inner_ty: &Type,
on_disk: &TokenStream,
kind: Kind,
nullable: bool,
) -> TokenStream {
let setter = format_ident!("set_{}", fname);
let off = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk, #fname) as u64
)?);
match kind {
Kind::Pod => quote! {
#vis fn #setter(
&self,
stack: &::bstack_raii::BStack,
value: #inner_ty,
) -> ::std::io::Result<()> {
stack.set(#off, ::bstack_raii::bytemuck::bytes_of(&value))
}
},
Kind::Ref if nullable => quote! {
#vis fn #setter(
&self,
stack: &::bstack_raii::BStack,
value: ::core::option::Option<::bstack_raii::BStackRef<#inner_ty>>,
) -> ::std::io::Result<()> {
let __ptr = value.map_or(0u64, |__r| __r.into_range().start());
stack.set(#off, __ptr.to_le_bytes())
}
},
Kind::Ref => quote! {
#vis fn #setter(
&self,
stack: &::bstack_raii::BStack,
value: ::bstack_raii::BStackRef<#inner_ty>,
) -> ::std::io::Result<()> {
stack.set(#off, value.into_range().start().to_le_bytes())
}
},
_ => quote!(),
}
}
pub(crate) fn replace_accessor(
vis: &syn::Visibility,
fname: &Ident,
inner_ty: &Type,
on_disk: &TokenStream,
kind: Kind,
nullable: bool,
) -> TokenStream {
let name = format_ident!("replace_{}", fname);
let off = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk, #fname) as u64
));
let size_od =
quote!(::core::mem::size_of::<<#inner_ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64);
let old_range = quote!(::bstack_raii::BStackRange::new(__old_off, #size_od));
match kind {
Kind::Owned => {
let handle_ty = quote!(::bstack_raii::BStackOwned<#inner_ty>);
let new_range = quote!({
let __h = __value.into_inner();
::bstack_raii::BStackBlock::range(&__h)
});
let rebuild = |range: TokenStream| {
quote!(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#inner_ty as ::bstack_raii::BStackBlock>::from_range(#range) },
)
})
};
let recon_old = rebuild(old_range.clone());
let rebuild_new = rebuild(quote!(__new_range));
replace_stack_method(
vis,
&name,
&handle_ty,
&off,
&new_range,
&recon_old,
&rebuild_new,
nullable,
)
}
Kind::Ref => {
let handle_ty = quote!(::bstack_raii::BStackRef<#inner_ty>);
let new_range = quote!(__value.into_range());
let rebuild = |range: TokenStream| quote!(unsafe { ::bstack_raii::BStackRef::<#inner_ty>::from_range(#range) });
let recon_old = rebuild(old_range.clone());
let rebuild_new = rebuild(quote!(__new_range));
replace_stack_method(
vis,
&name,
&handle_ty,
&off,
&new_range,
&recon_old,
&rebuild_new,
nullable,
)
}
Kind::Strong => {
let rc_ty = quote!(::bstack_raii::BStackRc<'__r, #inner_ty, __A>);
let ret_ty = if nullable {
quote!(::core::option::Option<#rc_ty>)
} else {
quote!(#rc_ty)
};
let recon_old = quote! {
{
let __old_data = unsafe {
::bstack_raii::BStackRef::<#inner_ty>::from_range(#old_range)
};
match <#inner_ty as ::bstack_raii::BStackShared>::strong_parts(__old_data, allocator) {
::std::result::Result::Ok((__d, __c)) => {
unsafe { ::bstack_raii::BStackRc::from_raw(__d, __c, allocator) }
}
::std::result::Result::Err(__e) => {
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::lost_raw(__e, ::std::vec![#old_range]));
}
}
}
};
let (consume_new, rebuild_new): (TokenStream, TokenStream) = (
quote!({
let (__nd, __nc) = __value.into_raw();
(__nd.into_range(), __nc)
}),
quote!(unsafe {
::bstack_raii::BStackRc::from_raw(
::bstack_raii::BStackRef::<#inner_ty>::from_range(__new_range),
__nc,
allocator,
)
}),
);
let body = if nullable {
quote! {
let __off = match #off {
::std::result::Result::Ok(__o) => __o,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, value)),
};
let __stack = allocator.stack();
let (__new, __back): (u64, ::core::option::Option<(::bstack_raii::BStackRange, ::core::option::Option<::bstack_raii::BStackRange>)>) =
match value {
::core::option::Option::Some(__value) => {
let (__new_range, __nc) = #consume_new;
(__new_range.start(), ::core::option::Option::Some((__new_range, __nc)))
}
::core::option::Option::None => (0u64, ::core::option::Option::None),
};
let __old_bytes = match __stack.swap(__off, __new.to_le_bytes()) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) => {
let __handback: #ret_ty = match __back {
::core::option::Option::Some((__new_range, __nc)) => {
::core::option::Option::Some(#rebuild_new)
}
::core::option::Option::None => ::core::option::Option::None,
};
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, __handback));
}
};
let __old_off = u64::from_le_bytes(
<[u8; 8]>::try_from(&__old_bytes[..8]).unwrap());
if __old_off == 0 {
::core::result::Result::Ok(::core::option::Option::None)
} else {
::core::result::Result::Ok(::core::option::Option::Some(#recon_old))
}
}
} else {
quote! {
let __off = match #off {
::std::result::Result::Ok(__o) => __o,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, value)),
};
let __stack = allocator.stack();
let (__new_range, __nc) = { let __value = value; #consume_new };
let __new = __new_range.start();
let __old_bytes = match __stack.swap(__off, __new.to_le_bytes()) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, #rebuild_new)),
};
let __old_off = u64::from_le_bytes(
<[u8; 8]>::try_from(&__old_bytes[..8]).unwrap());
::core::result::Result::Ok(#recon_old)
}
};
quote! {
#vis fn #name<'__r, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__r __A,
value: #ret_ty,
) -> ::core::result::Result<#ret_ty, ::bstack_raii::ReplaceError<#ret_ty>> {
#body
}
}
}
_ => quote!(),
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn replace_stack_method(
vis: &syn::Visibility,
name: &Ident,
handle_ty: &TokenStream,
off: &TokenStream,
new_range: &TokenStream,
recon_old: &TokenStream,
rebuild_new: &TokenStream,
nullable: bool,
) -> TokenStream {
if nullable {
quote! {
#vis fn #name(
&self,
stack: &::bstack_raii::BStack,
value: ::core::option::Option<#handle_ty>,
) -> ::core::result::Result<
::core::option::Option<#handle_ty>,
::bstack_raii::ReplaceError<::core::option::Option<#handle_ty>>,
> {
let __off = match #off {
::std::result::Result::Ok(__o) => __o,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, value)),
};
let (__new, __new_range_opt): (u64, ::core::option::Option<::bstack_raii::BStackRange>) =
match value {
::core::option::Option::Some(__value) => {
let __new_range: ::bstack_raii::BStackRange = #new_range;
(__new_range.start(), ::core::option::Option::Some(__new_range))
}
::core::option::Option::None => (0u64, ::core::option::Option::None),
};
let __old_bytes = match stack.swap(__off, __new.to_le_bytes()) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) => {
let __handback: ::core::option::Option<#handle_ty> = match __new_range_opt {
::core::option::Option::Some(__new_range) => ::core::option::Option::Some(#rebuild_new),
::core::option::Option::None => ::core::option::Option::None,
};
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, __handback));
}
};
let __old_off = u64::from_le_bytes(
<[u8; 8]>::try_from(&__old_bytes[..8]).unwrap());
if __old_off == 0 {
::core::result::Result::Ok(::core::option::Option::None)
} else {
::core::result::Result::Ok(::core::option::Option::Some(#recon_old))
}
}
}
} else {
quote! {
#vis fn #name(
&self,
stack: &::bstack_raii::BStack,
value: #handle_ty,
) -> ::core::result::Result<#handle_ty, ::bstack_raii::ReplaceError<#handle_ty>> {
let __off = match #off {
::std::result::Result::Ok(__o) => __o,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, value)),
};
let __new_range: ::bstack_raii::BStackRange = { let __value = value; #new_range };
let __new = __new_range.start();
let __old_bytes = match stack.swap(__off, __new.to_le_bytes()) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, #rebuild_new)),
};
let __old_off = u64::from_le_bytes(
<[u8; 8]>::try_from(&__old_bytes[..8]).unwrap());
::core::result::Result::Ok(#recon_old)
}
}
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn array_mut_methods(
vis: &syn::Visibility,
fname: &Ident,
elem: &TokenStream,
on_disk: &TokenStream,
kind: Kind,
dims: &[&syn::Expr],
total: &TokenStream,
size_elem: &TokenStream,
elem_nullable: bool,
) -> Vec<TokenStream> {
let base = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk, #fname) as u64
));
let is_strong = kind == Kind::Strong;
let is_ref = kind == Kind::Ref;
let oob = quote!(::std::io::Error::new(
::std::io::ErrorKind::InvalidInput,
"array index out of bounds",
));
let leaf_handle = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__m, #elem, __A>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem>),
_ => unreachable!(),
};
let elem_leaf = if elem_nullable {
quote!(::core::option::Option<#leaf_handle>)
} else {
leaf_handle.clone()
};
let whole_ty = nested_ty(dims, &elem_leaf);
let consume = |v: TokenStream| match kind {
Kind::Owned => quote!({
let __h = (#v).into_inner();
(
::bstack_raii::BStackBlock::range(&__h).start(),
::core::option::Option::<::bstack_raii::BStackRange>::None,
)
}),
Kind::Ref => quote!((
(#v).into_range().start(),
::core::option::Option::<::bstack_raii::BStackRange>::None,
)),
Kind::Strong => quote!({
let (__d, __c) = (#v).into_raw();
(__d.into_range().start(), __c)
}),
_ => unreachable!(),
};
let rebuild = |off: TokenStream, ctrl: TokenStream| match kind {
Kind::Owned => quote!(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(#off, #size_elem)) })
}),
Kind::Ref => quote!(unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(#off, #size_elem))
}),
Kind::Strong => quote!(unsafe {
::bstack_raii::BStackRc::from_raw(
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(#off, #size_elem)),
#ctrl,
allocator,
)
}),
_ => unreachable!(),
};
let recon_old = |off: TokenStream| match kind {
Kind::Owned => quote!(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(#off, #size_elem)) })
}),
Kind::Ref => quote!(unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(#off, #size_elem))
}),
Kind::Strong => quote!({
let __old_data = unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(#off, #size_elem))
};
match <#elem as ::bstack_raii::BStackShared>::strong_parts(__old_data, allocator) {
::std::result::Result::Ok((__od2, __oc2)) =>
unsafe { ::bstack_raii::BStackRc::from_raw(__od2, __oc2, allocator) },
::std::result::Result::Err(__e) => {
let __r = ::bstack_raii::BStackRange::new(#off, #size_elem);
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::lost_raw(__e, ::std::vec![__r]));
}
}
}),
_ => unreachable!(),
};
let cpat = if is_strong { quote!(__c) } else { quote!(_) };
let mut out: Vec<TokenStream> = Vec::new();
let replace_at = format_ident!("replace_{}_at", fname);
let elem_body = if elem_nullable {
let consume_some = consume(quote!(__v));
let rb = rebuild(quote!(__o), quote!(__c));
let old = recon_old(quote!(__old_off));
quote! {
let (__new, __back): (
u64,
::core::option::Option<(u64, ::core::option::Option<::bstack_raii::BStackRange>)>,
) = match value {
::core::option::Option::Some(__v) => {
let (__o, __c) = #consume_some;
(__o, ::core::option::Option::Some((__o, __c)))
}
::core::option::Option::None => (0u64, ::core::option::Option::None),
};
let __old_bytes = match __stack.swap(__off, __new.to_le_bytes()) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) => {
let __hb: #elem_leaf = match __back {
::core::option::Option::Some((__o, #cpat)) => ::core::option::Option::Some(#rb),
::core::option::Option::None => ::core::option::Option::None,
};
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, __hb));
}
};
let __old_off = u64::from_le_bytes(
<[u8; 8]>::try_from(&__old_bytes[..8]).unwrap());
if __old_off == 0 {
::core::result::Result::Ok(::core::option::Option::None)
} else {
::core::result::Result::Ok(::core::option::Option::Some(#old))
}
}
} else {
let consume_v = consume(quote!(value));
let rb = rebuild(quote!(__new), quote!(__c));
let old = recon_old(quote!(__old_off));
quote! {
let (__new, #cpat): (u64, ::core::option::Option<::bstack_raii::BStackRange>) = #consume_v;
let __old_bytes = match __stack.swap(__off, __new.to_le_bytes()) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, #rb)),
};
let __old_off = u64::from_le_bytes(
<[u8; 8]>::try_from(&__old_bytes[..8]).unwrap());
::core::result::Result::Ok(#old)
}
};
out.push(quote! {
#vis fn #replace_at<'__m, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__m __A,
index: usize,
value: #elem_leaf,
) -> ::core::result::Result<#elem_leaf, ::bstack_raii::ReplaceError<#elem_leaf>> {
if index >= (#total) {
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(#oob, value));
}
let __stack = allocator.stack();
let __base = match #base {
::std::result::Result::Ok(__o) => __o,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, value)),
};
let __off = __base + (index as u64) * 8;
#elem_body
}
});
let decl_ncs = if is_strong {
quote!(let mut __ncs =
[::core::option::Option::<::bstack_raii::BStackRange>::None; #total];)
} else {
quote!()
};
let consume_write = |k: &Ident, leaf: &Ident| {
let store_ctrl = if is_strong {
quote!(__ncs[#k] = __c;)
} else {
quote!()
};
if elem_nullable {
let cs = consume(quote!(__v));
quote! {
match #leaf {
::core::option::Option::Some(__v) => {
let (__o, #cpat) = #cs;
__news[#k] = __o;
#store_ctrl
}
::core::option::Option::None => { __news[#k] = 0u64; }
}
}
} else {
let cs = consume(quote!(#leaf));
quote! {
let (__o, #cpat) = #cs;
__news[#k] = __o;
#store_ctrl
}
}
};
let consume_all = nested_consume(dims, "e!(value), &consume_write);
let new_read = |k: &Ident| {
let rb = rebuild(quote!(__news[#k]), quote!(__ncs[#k]));
if elem_nullable {
quote!(if __news[#k] == 0u64 {
::core::option::Option::None
} else {
::core::option::Option::Some(#rb)
})
} else {
rb
}
};
let new_nested = nested_build(dims, &elem_leaf, &new_read);
let old_read = |k: &Ident| {
let ro = recon_old(quote!(__oldoffs[#k]));
if elem_nullable {
quote!(if __oldoffs[#k] == 0u64 {
::core::option::Option::None
} else {
::core::option::Option::Some(#ro)
})
} else {
ro
}
};
let old_nested = nested_build(dims, &elem_leaf, &old_read);
let replace_whole = format_ident!("replace_{}", fname);
out.push(quote! {
#vis fn #replace_whole<'__m, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__m __A,
value: #whole_ty,
) -> ::core::result::Result<#whole_ty, ::bstack_raii::ReplaceError<#whole_ty>> {
let __stack = allocator.stack();
let __base = match #base {
::std::result::Result::Ok(__o) => __o,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, value)),
};
let mut __news = [0u64; #total];
#decl_ncs
#consume_all
let __old_bytes = match __stack.swap(__base, ::bstack_raii::bytemuck::bytes_of(&__news)) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) => {
let __hb: #whole_ty = #new_nested;
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, __hb));
}
};
let mut __oldoffs = [0u64; #total];
for __i in 0..(#total) {
__oldoffs[__i] = u64::from_le_bytes(
<[u8; 8]>::try_from(&__old_bytes[__i * 8..__i * 8 + 8]).unwrap());
}
let __old: #whole_ty = #old_nested;
::core::result::Result::Ok(__old)
}
});
if is_ref {
let set_at = format_ident!("set_{}_at", fname);
let new_off = if elem_nullable {
quote!(match value {
::core::option::Option::Some(__v) => __v.into_range().start(),
::core::option::Option::None => 0u64,
})
} else {
quote!(value.into_range().start())
};
out.push(quote! {
#vis fn #set_at<'__m, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__m __A,
index: usize,
value: #elem_leaf,
) -> ::std::io::Result<()> {
if index >= (#total) {
return ::std::result::Result::Err(#oob);
}
let __off = #base? + (index as u64) * 8;
let __new: u64 = #new_off;
allocator.stack().set(__off, __new.to_le_bytes())
}
});
let set_whole = format_ident!("set_{}", fname);
let set_write = |k: &Ident, leaf: &Ident| {
if elem_nullable {
quote! {
__news[#k] = match #leaf {
::core::option::Option::Some(__v) => __v.into_range().start(),
::core::option::Option::None => 0u64,
};
}
} else {
quote!(__news[#k] = #leaf.into_range().start();)
}
};
let set_consume = nested_consume(dims, "e!(value), &set_write);
out.push(quote! {
#vis fn #set_whole<'__m, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__m __A,
value: #whole_ty,
) -> ::std::io::Result<()> {
let mut __news = [0u64; #total];
#set_consume
allocator.stack().set(#base?, ::bstack_raii::bytemuck::bytes_of(&__news))
}
});
}
out
}
pub(crate) fn foreign_mut_methods(
vis: &syn::Visibility,
fname: &Ident,
ftarget: &TokenStream,
on_disk: &TokenStream,
kind: Kind,
nullable: bool,
) -> Vec<TokenStream> {
let off = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk, #fname) as u64
));
let dual = match kind {
Kind::Owned => quote!(::bstack_raii::ForeignOwned<'__m, #ftarget>),
Kind::Strong => quote!(::bstack_raii::ForeignRc<'__m, #ftarget>),
Kind::Weak => quote!(::bstack_raii::ForeignWeak<'__m, #ftarget>),
Kind::Ref => quote!(::bstack_raii::Foreign<'__m, #ftarget>),
_ => unreachable!(),
};
let val_ty = if nullable {
quote!(::core::option::Option<#dual>)
} else {
dual.clone()
};
let consume = |v: TokenStream| match kind {
Kind::Owned | Kind::Strong | Kind::Weak => quote!((#v).into_foreign().repr()),
Kind::Ref => quote!((#v).repr()),
_ => unreachable!(),
};
let rebuild = |r: TokenStream| match kind {
Kind::Owned => quote!(unsafe {
::bstack_raii::ForeignOwned::from_foreign(
::bstack_raii::Foreign::<#ftarget>::from_repr(#r))
}),
Kind::Strong => quote!(unsafe {
::bstack_raii::ForeignRc::from_foreign(
::bstack_raii::Foreign::<#ftarget>::from_repr(#r))
}),
Kind::Weak => quote!(unsafe {
::bstack_raii::ForeignWeak::from_foreign(
::bstack_raii::Foreign::<#ftarget>::from_repr(#r))
}),
Kind::Ref => quote!(unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(#r) }),
_ => unreachable!(),
};
let mut out: Vec<TokenStream> = Vec::new();
let replace = format_ident!("replace_{}", fname);
let setup = quote! {
let __stack = allocator.stack();
let __off = match #off {
::std::result::Result::Ok(__o) => __o,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(
::bstack_raii::ReplaceError::recovered(__e, value)),
};
};
let take_old = quote! {
let __old_raw: ::bstack_raii::WidePtr =
::bstack_raii::bytemuck::pod_read_unaligned(&__old_bytes[..16]);
let __old: ::bstack_raii::WidePtr =
match ::bstack_raii::registry::resolve_self_repr(__old_raw, __stack) {
::std::result::Result::Ok(__r) => __r,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(::bstack_raii::ReplaceError::lost(__e)),
};
};
let replace_body = if nullable {
let consume_some = consume(quote!(__v));
let rb_new = rebuild(quote!(__r));
let rb_old = rebuild(quote!(__old));
quote! {
#setup
let (__new, __back): (
::bstack_raii::WidePtr,
::core::option::Option<::bstack_raii::WidePtr>,
) = match value {
::core::option::Option::Some(__v) => {
let __r = #consume_some;
(::bstack_raii::registry::home_relative_repr(__r, __stack),
::core::option::Option::Some(__r))
}
::core::option::Option::None =>
(::bstack_raii::WidePtr::NULL, ::core::option::Option::None),
};
let __old_bytes = match __stack.swap(__off, ::bstack_raii::bytemuck::bytes_of(&__new)) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) => {
let __hb: #val_ty = match __back {
::core::option::Option::Some(__r) => ::core::option::Option::Some(#rb_new),
::core::option::Option::None => ::core::option::Option::None,
};
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, __hb));
}
};
let __old_raw: ::bstack_raii::WidePtr =
::bstack_raii::bytemuck::pod_read_unaligned(&__old_bytes[..16]);
if __old_raw.offset().get() == 0 {
::core::result::Result::Ok(::core::option::Option::None)
} else {
let __old: ::bstack_raii::WidePtr =
match ::bstack_raii::registry::resolve_self_repr(__old_raw, __stack) {
::std::result::Result::Ok(__r) => __r,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(::bstack_raii::ReplaceError::lost(__e)),
};
::core::result::Result::Ok(::core::option::Option::Some(#rb_old))
}
}
} else {
let consume_v = consume(quote!(value));
let rb_new = rebuild(quote!(__new_explicit));
let rb_old = rebuild(quote!(__old));
quote! {
#setup
let __new_explicit: ::bstack_raii::WidePtr = #consume_v;
let __new: ::bstack_raii::WidePtr =
::bstack_raii::registry::home_relative_repr(__new_explicit, __stack);
let __old_bytes = match __stack.swap(__off, ::bstack_raii::bytemuck::bytes_of(&__new)) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) =>
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, #rb_new)),
};
#take_old
::core::result::Result::Ok(#rb_old)
}
};
out.push(quote! {
#vis fn #replace<'__m, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__m __A,
value: #val_ty,
) -> ::core::result::Result<#val_ty, ::bstack_raii::ReplaceError<#val_ty>> {
#replace_body
}
});
if kind == Kind::Ref {
let setter = format_ident!("set_{}", fname);
let new_repr = if nullable {
quote!(match value {
::core::option::Option::Some(__v) => __v.repr(),
::core::option::Option::None => ::bstack_raii::WidePtr::NULL,
})
} else {
quote!(value.repr())
};
out.push(quote! {
#vis fn #setter<'__m, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__m __A,
value: #val_ty,
) -> ::std::io::Result<()> {
let __new: ::bstack_raii::WidePtr =
::bstack_raii::registry::home_relative_repr(#new_repr, allocator.stack());
allocator
.stack()
.set(#off?, ::bstack_raii::bytemuck::bytes_of(&__new))
}
});
}
out
}
pub(crate) fn ctor_field(
fname: &Ident,
inner_ty: &Type,
kind: Kind,
nullable: bool,
) -> (TokenStream, TokenStream, TokenStream) {
let (handle_ty, to_offset): (TokenStream, TokenStream) = match kind {
Kind::Pod => {
return (quote!(#fname: #inner_ty,), quote!(), quote!(#fname,));
}
Kind::Owned => (
quote!(::bstack_raii::BStackOwned<#inner_ty>),
quote!({
let __h = __handle.into_inner();
::bstack_raii::BStackBlock::range(&__h).start()
}),
),
Kind::Strong => (
quote!(::bstack_raii::BStackRc<'__ctor, #inner_ty, __A>),
quote!({
let (__d, _) = __handle.into_raw();
__d.into_range().start()
}),
),
Kind::Ref => (
quote!(::bstack_raii::BStackRef<#inner_ty>),
quote!(__handle.into_range().start()),
),
Kind::Weak => unreachable!("weak fields are wired via set_<field>, not the constructor"),
Kind::Embed => unreachable!("#[embed] fields are handled before ctor_field"),
};
if nullable {
(
quote!(#fname: ::core::option::Option<#handle_ty>,),
quote! {
let #fname: u64 = match #fname {
::core::option::Option::Some(__handle) => #to_offset,
::core::option::Option::None => 0u64,
};
},
quote!(#fname,),
)
} else {
(
quote!(#fname: #handle_ty,),
quote! { let #fname: u64 = { let __handle = #fname; #to_offset }; },
quote!(#fname,),
)
}
}
pub(crate) fn mv_ty_as_ctor(ty: &TokenStream) -> TokenStream {
rename_lifetime(ty, "__mv", "__ctor")
}
pub(crate) fn rename_lifetime(ts: &TokenStream, from: &str, to: &str) -> TokenStream {
use proc_macro2::{Ident, TokenTree};
ts.clone()
.into_iter()
.map(|tt| match tt {
TokenTree::Ident(id) if id == from => TokenTree::Ident(Ident::new(to, id.span())),
TokenTree::Group(g) => TokenTree::Group(proc_macro2::Group::new(
g.delimiter(),
rename_lifetime(&g.stream(), from, to),
)),
other => other,
})
.collect()
}
pub(crate) fn move_field(
cap: &Ident,
inner_ty: &Type,
kind: Kind,
nullable: bool,
) -> (TokenStream, TokenStream) {
let size_od =
quote!(::core::mem::size_of::<<#inner_ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64);
match kind {
Kind::Pod => (quote!(#inner_ty), quote!(#cap)),
Kind::Embed => unreachable!("#[embed] fields are handled before move_field"),
Kind::Weak => {
let ty = quote! {
::core::option::Option<::bstack_raii::BStackWeak<'__mv, #inner_ty, __A>>
};
let recon = quote! {
if #cap == 0 {
::core::option::Option::None
} else {
let __ctrl = unsafe {
::bstack_raii::BStackRef::<
<#inner_ty as ::bstack_raii::BStackWeakable>::Control
>::from_range(::bstack_raii::BStackRange::new(
#cap,
::core::mem::size_of::<
<#inner_ty as ::bstack_raii::BStackWeakable>::Control
>() as u64,
))
};
::core::option::Option::Some(
unsafe { ::bstack_raii::BStackWeak::from_raw(__ctrl, __alloc) }
)
}
};
(ty, recon)
}
Kind::Owned => wrap_move(
quote!(::bstack_raii::BStackOwned<#inner_ty>),
quote! {
unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#inner_ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(#cap, #size_od),
) },
)
}
},
cap,
nullable,
),
Kind::Ref => wrap_move(
quote!(::bstack_raii::BStackRef<#inner_ty>),
quote! {
unsafe {
::bstack_raii::BStackRef::<#inner_ty>::from_range(
::bstack_raii::BStackRange::new(#cap, #size_od),
)
}
},
cap,
nullable,
),
Kind::Strong => wrap_move(
quote!(::bstack_raii::BStackRc<'__mv, #inner_ty, __A>),
quote! {
{
let __data = unsafe {
::bstack_raii::BStackRef::<#inner_ty>::from_range(
::bstack_raii::BStackRange::new(#cap, #size_od),
)
};
let (__d, __c) =
<#inner_ty as ::bstack_raii::BStackShared>::strong_parts(__data, __alloc)?;
unsafe { ::bstack_raii::BStackRc::from_raw(__d, __c, __alloc) }
}
},
cap,
nullable,
),
}
}
pub(crate) fn wrap_move(
ty: TokenStream,
build: TokenStream,
cap: &Ident,
nullable: bool,
) -> (TokenStream, TokenStream) {
if nullable {
(
quote!(::core::option::Option<#ty>),
quote! {
if #cap == 0 {
::core::option::Option::None
} else {
::core::option::Option::Some(#build)
}
},
)
} else {
(ty, build)
}
}
pub(crate) fn weak_setter(
vis: &syn::Visibility,
fname: &Ident,
fty: &Type,
on_disk: &TokenStream,
) -> TokenStream {
let setter = format_ident!("set_{}", fname);
quote! {
#vis fn #setter<'__s, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__s __A,
weak: ::bstack_raii::BStackWeak<'__s, #fty, __A>,
) -> ::core::result::Result<
(),
::bstack_raii::ReplaceError<::bstack_raii::BStackWeak<'__s, #fty, __A>>,
> {
let __field = match ::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk, #fname) as u64,
).and_then(::bstack_raii::NonNullOffset::from_field) {
::core::result::Result::Ok(__f) => __f,
::core::result::Result::Err(__e) => {
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, weak));
}
};
unsafe { ::bstack_raii::BStackWeakable::set_weak_field(allocator, __field, weak) }
}
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn constructor(
vis: &syn::Visibility,
on_disk: &TokenStream,
on_disk_ctor: &TokenStream,
mode: Mode,
params: &[TokenStream],
preps: &[TokenStream],
inits: &[TokenStream],
handbacks: &[TokenStream],
handback_tys: &[TokenStream],
post: &[TokenStream],
) -> TokenStream {
let header = quote! {
__bstack_header: ::bstack_raii::BlockHeader {
size: ::core::mem::size_of::<#on_disk>() as u64,
tag: <Self as ::bstack_raii::BStackCast>::eightcc(),
},
};
let size = quote!(::core::mem::size_of::<#on_disk>() as u64);
let has_owning = !handbacks.is_empty();
let handback_tuple = quote!(( #(#handback_tys,)* ));
let wrap_err = |err: TokenStream| -> TokenStream {
if !has_owning {
return quote!({ return ::core::result::Result::Err(#err); });
}
quote! {
{
let __e: ::std::io::Error = #err;
#[allow(unused_variables)]
let __alloc = allocator;
#[allow(unused_variables)]
let __stack = allocator.stack();
let __recovered: ::std::io::Result<#handback_tuple> =
(|| ::core::result::Result::Ok(( #(#handbacks,)* )))();
return match __recovered {
::core::result::Result::Ok(__f) => ::core::result::Result::Err(
::bstack_raii::ConstructError::recovered(__e, __f),
),
::core::result::Result::Err(_) => ::core::result::Result::Err(
::bstack_raii::ConstructError::lost(__e),
),
};
}
}
};
let ret_wrap = |ok: &TokenStream| -> TokenStream {
if has_owning {
quote!(::core::result::Result<#ok, ::bstack_raii::ConstructError<#handback_tuple>>)
} else {
quote!(::std::io::Result<#ok>)
}
};
match mode {
Mode::Plain | Mode::Rc => {
let injected = if let Mode::Rc = mode {
quote!(__bstack_refcount: 1u64,)
} else {
quote!()
};
let ret = if let Mode::Rc = mode {
quote!(::bstack_raii::BStackRc<'__ctor, Self, __A>)
} else {
quote!(::bstack_raii::BStackOwned<Self>)
};
let finish = if let Mode::Rc = mode {
quote! {
::std::result::Result::Ok(unsafe {
::bstack_raii::BStackRc::from_raw(
::bstack_raii::BStackRef::from_range(__data),
::core::option::Option::None,
allocator,
)
})
}
} else {
quote! {
::std::result::Result::Ok(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <Self as ::bstack_raii::BStackBlock>::from_range(__data) },
)
})
}
};
let ret_ty = ret_wrap(&ret);
let on_alloc_fail = wrap_err(quote!(__e));
let on_write_fail = wrap_err(quote!(__e));
quote! {
#[allow(clippy::too_many_arguments)]
#vis fn new<'__ctor, __A: ::bstack_raii::BStackRaiiAllocator>(
allocator: &'__ctor __A,
#(#params)*
) -> #ret_ty {
#(#preps)*
let __on_disk = #on_disk_ctor {
#header
#injected
#(#inits)*
};
let mut __slice = match allocator.alloc(#size) {
::std::result::Result::Ok(__s) => __s,
::std::result::Result::Err(__e) => #on_alloc_fail
};
let __data = __slice.as_range();
if let ::std::result::Result::Err(__e) =
__slice.write_range(0, ::bstack_raii::bytemuck::bytes_of(&__on_disk))
{
let _ = allocator.dealloc(__slice);
#on_write_fail
}
#(#post)*
#finish
}
}
}
Mode::RcWeak => {
let ctrl_size = quote! {
::core::mem::size_of::<<Self as ::bstack_raii::BStackWeakable>::Control>() as u64
};
let ret = quote!(::bstack_raii::BStackRc<'__ctor, Self, __A>);
let ret_ty = ret_wrap(&ret);
let on_alloc_fail = wrap_err(quote!(__e));
let on_commit_fail = wrap_err(quote!(__e));
quote! {
#[allow(clippy::too_many_arguments)]
#vis fn new<'__ctor, __A: ::bstack_raii::BStackRaiiAllocator>(
allocator: &'__ctor __A,
#(#params)*
) -> #ret_ty {
#(#preps)*
let __blocks = match ::bstack_raii::BStackRaiiAllocator::alloc_many(allocator, &[#size, #ctrl_size]) {
::std::result::Result::Ok(__b) => __b,
::std::result::Result::Err(__e) => #on_alloc_fail
};
let __data = __blocks[0];
let __ctrl = __blocks[1];
let __on_disk = #on_disk_ctor {
#header
__bstack_ctrl: __ctrl.start(),
#(#inits)*
};
let __ctrl_payload = <Self as ::bstack_raii::BStackWeakable>::build_control_payload(__data.start());
let __writes: [(u64, &[u8]); 2] = [
(
__data.start(),
::bstack_raii::bytemuck::bytes_of(&__on_disk),
),
(__ctrl.start(), &__ctrl_payload),
];
if let ::std::result::Result::Err(__e) =
allocator.stack().set_batched(__writes)
{
let _ = unsafe { ::bstack_raii::BStackRaiiAllocator::free_many(allocator, [__data, __ctrl]) };
#on_commit_fail
}
#(#post)*
::std::result::Result::Ok(unsafe {
::bstack_raii::BStackRc::from_raw(
::bstack_raii::BStackRef::from_range(__data),
::core::option::Option::Some(__ctrl),
allocator,
)
})
}
}
}
}
}
pub(crate) fn child_range_stmt(
fname: &Ident,
inner_ty: &Type,
nullable: bool,
body: TokenStream,
) -> TokenStream {
let core = quote! {
let __range = ::bstack_raii::BStackRange::new(
__off,
::core::mem::size_of::<<#inner_ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64,
);
let __child = unsafe { ::bstack_raii::BStackRef::<#inner_ty>::from_range(__range) };
#body
};
let _ = nullable;
quote! { { let __off = __on_disk.#fname; if __off != 0 { #core } } }
}
pub(crate) fn weak_drop_stmt(fname: &Ident, inner_ty: &Type) -> TokenStream {
quote! {
{
let __off = __on_disk.#fname;
if __off != 0 {
let __ctrl = unsafe {
::bstack_raii::BStackRef::<
<#inner_ty as ::bstack_raii::BStackWeakable>::Control
>::from_range(::bstack_raii::BStackRange::new(
__off,
::core::mem::size_of::<
<#inner_ty as ::bstack_raii::BStackWeakable>::Control
>() as u64,
))
};
unsafe { ::bstack_raii::WeakRef::<#inner_ty>::new(__ctrl) }.bstack_drop(allocator)?;
}
}
}
}
pub(crate) fn clone_field_stmt(fname: &Ident, inner_ty: &Type, kind: Kind) -> Option<TokenStream> {
match kind {
Kind::Owned => Some(quote! {
{
let __coff: u64 = __od.#fname;
if __coff != 0 {
let __child = unsafe { <#inner_ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
__coff,
::core::mem::size_of::<
<#inner_ty as ::bstack_raii::BStackBlock>::OnDisk
>() as u64,
),
) };
let __new = __child.__bstack_clone_into(allocator, __plan)?;
__od.#fname = __new.start();
}
}
}),
Kind::Strong => Some(quote! {
{
let __coff: u64 = __od.#fname;
if __coff != 0 {
let __child = unsafe {
::bstack_raii::BStackRef::<#inner_ty>::from_range(
::bstack_raii::BStackRange::new(
__coff,
::core::mem::size_of::<
<#inner_ty as ::bstack_raii::BStackBlock>::OnDisk
>() as u64,
),
)
};
__plan.bump_strong(__child, allocator)?;
}
}
}),
Kind::Weak => Some(quote! {
{
let __coff: u64 = __od.#fname;
if __coff != 0 {
__plan.bump_weak(__coff)?;
}
}
}),
Kind::Ref | Kind::Pod | Kind::Embed => None,
}
}
pub(crate) fn shared_impl(mode: Mode, name: &Ident) -> TokenStream {
match mode {
Mode::Plain => quote!(),
Mode::Rc => quote! {
impl ::bstack_raii::BStackShared for #name {
fn drop_strong_ref<__A: ::bstack_raii::BStackRaiiAllocator>(
data: ::bstack_raii::BStackRef<Self>,
allocator: &__A,
) -> ::std::io::Result<()> {
use ::bstack_raii::BStackDrop as _;
unsafe { ::bstack_raii::StrongRef::new(data) }.bstack_drop(allocator)
}
fn strong_parts<__A: ::bstack_raii::BStackRaiiAllocator>(
data: ::bstack_raii::BStackRef<Self>,
_allocator: &__A,
) -> ::std::io::Result<(
::bstack_raii::BStackRef<Self>,
::core::option::Option<::bstack_raii::BStackRange>,
)> {
::std::result::Result::Ok((data, ::core::option::Option::None))
}
}
},
Mode::RcWeak => quote! {
impl ::bstack_raii::BStackShared for #name {
fn drop_strong_ref<__A: ::bstack_raii::BStackRaiiAllocator>(
data: ::bstack_raii::BStackRef<Self>,
allocator: &__A,
) -> ::std::io::Result<()> {
use ::bstack_raii::BStackDrop as _;
unsafe { ::bstack_raii::StrongWeakRef::from_disk(data, allocator)? }
.bstack_drop(allocator)
}
fn strong_parts<__A: ::bstack_raii::BStackRaiiAllocator>(
data: ::bstack_raii::BStackRef<Self>,
allocator: &__A,
) -> ::std::io::Result<(
::bstack_raii::BStackRef<Self>,
::core::option::Option<::bstack_raii::BStackRange>,
)> {
let __swr = unsafe { ::bstack_raii::StrongWeakRef::from_disk(data, allocator)? };
::std::result::Result::Ok((
__swr.data_ref(),
::core::option::Option::Some(__swr.ctrl_ref().into_range()),
))
}
}
},
}
}
pub(crate) fn weakable_items(
mode: Mode,
name: &Ident,
control: &Ident,
ctrl_eightcc: &TokenStream,
vis: &syn::Visibility,
) -> TokenStream {
if mode == Mode::RcWeak {
quote! {
#[repr(C, packed)]
#[derive(::core::clone::Clone, ::core::marker::Copy)]
#vis struct #control {
__bstack_header: ::bstack_raii::BlockHeader,
__bstack_strong: u64,
__bstack_weak: u64,
__bstack_x: u64,
}
unsafe impl ::bstack_raii::Zeroable for #control {}
unsafe impl ::bstack_raii::Pod for #control {}
impl ::bstack_raii::BStackWeakable for #name {
type Control = #control;
fn control_eightcc() -> ::bstack_raii::EightCC { #ctrl_eightcc }
}
}
} else {
quote!()
}
}
pub(crate) fn foreign_field(
ctx: &FieldCtx,
ftarget: &Type,
nullable: bool,
) -> syn::Result<FieldParts> {
let &FieldCtx {
vis,
fname,
field,
kind,
on_disk_ty,
type_params,
..
} = ctx;
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
validate_foreign_target(
kind,
ftarget,
&field.ty,
"`Foreign<T>`",
format_ident!("__bstack_foreign_target_{}", fname),
!type_mentions_any(ftarget, type_params),
&mut parts.wrapper_defs,
)?;
parts
.on_disk_fields
.push(quote!(#fname: ::bstack_raii::WidePtr,));
let field_ty = quote!(::bstack_raii::Foreign<#ftarget>);
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
let resolved_cap = quote!(::bstack_raii::registry::resolve_self_repr(#cap, __stack)?);
let (mv_leaf_ty, mv_leaf_expr) = match kind {
Kind::Owned => (
quote!(::bstack_raii::ForeignOwned<'__mv, #ftarget>),
quote!(unsafe {
::bstack_raii::ForeignOwned::from_foreign(
::bstack_raii::Foreign::from_repr(#resolved_cap))
}),
),
Kind::Strong => (
quote!(::bstack_raii::ForeignRc<'__mv, #ftarget>),
quote!(unsafe {
::bstack_raii::ForeignRc::from_foreign(
::bstack_raii::Foreign::from_repr(#resolved_cap))
}),
),
Kind::Weak => (
quote!(::bstack_raii::ForeignWeak<'__mv, #ftarget>),
quote!(unsafe {
::bstack_raii::ForeignWeak::from_foreign(
::bstack_raii::Foreign::from_repr(#resolved_cap))
}),
),
_ => (
quote!(::bstack_raii::Foreign<'__mv, #ftarget>),
quote!(unsafe { ::bstack_raii::Foreign::from_repr(#resolved_cap) }),
),
};
if nullable {
parts.accessors.push(quote! {
#vis fn #getter<'__f>(
&self,
stack: &'__f ::bstack_raii::BStack,
) -> ::std::io::Result<
::core::option::Option<::bstack_raii::Foreign<'__f, #ftarget>>,
> {
let mut __buf = ::std::vec![0u8; ::core::mem::size_of::<#on_disk_ty>()];
let __r = unsafe { ::bstack_raii::BStackRef::<Self>::from_range(self.0) };
let __od: #on_disk_ty = *__r.read_on_disk(stack, &mut __buf)?;
let __p = __od.#fname;
let __out = if __p.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr = ::bstack_raii::registry::resolve_self_repr(__p, stack)?;
::core::option::Option::Some(unsafe {
::bstack_raii::Foreign::from_repr(__repr)
})
};
::std::result::Result::Ok(__out)
}
});
parts
.ctor_params
.push(quote!(#fname: ::core::option::Option<#field_ty>,));
parts.ctor_preps.push(quote! {
let #fname: ::bstack_raii::WidePtr = match #fname {
::core::option::Option::Some(__f) =>
::bstack_raii::registry::home_relative_repr(__f.repr(), allocator.stack()),
::core::option::Option::None => ::bstack_raii::WidePtr::NULL,
};
});
parts.ctor_inits.push(quote!(#fname,));
parts
.mv_types
.push(quote!(::core::option::Option<#mv_leaf_ty>));
parts.mv_recon.push(quote! {
if #cap.offset().get() == 0 {
::core::option::Option::None
} else {
::core::option::Option::Some(#mv_leaf_expr)
}
});
} else {
parts.accessors.push(quote! {
#vis fn #getter<'__f>(
&self,
stack: &'__f ::bstack_raii::BStack,
) -> ::std::io::Result<::bstack_raii::Foreign<'__f, #ftarget>> {
let mut __buf = ::std::vec![0u8; ::core::mem::size_of::<#on_disk_ty>()];
let __r = unsafe { ::bstack_raii::BStackRef::<Self>::from_range(self.0) };
let __od: #on_disk_ty = *__r.read_on_disk(stack, &mut __buf)?;
let __repr = ::bstack_raii::registry::resolve_self_repr(__od.#fname, stack)?;
::std::result::Result::Ok(unsafe {
::bstack_raii::Foreign::from_repr(__repr)
})
}
});
parts.ctor_params.push(quote!(#fname: #field_ty,));
parts.ctor_preps.push(quote!(
let #fname: ::bstack_raii::WidePtr =
::bstack_raii::registry::home_relative_repr(#fname.repr(), allocator.stack());
));
parts.ctor_inits.push(quote!(#fname,));
parts.mv_types.push(quote!(#mv_leaf_ty));
parts.mv_recon.push(quote!(#mv_leaf_expr));
}
if !matches!(kind, Kind::Ref | Kind::Pod | Kind::Embed) {
let elem_drop = foreign_elem_drop(kind, ftarget);
parts.drop_stmts.push(quote! {
{
let __fp: ::bstack_raii::WidePtr = __on_disk.#fname;
#elem_drop
}
});
}
if !matches!(kind, Kind::Ref | Kind::Pod | Kind::Embed) {
let elem_clone = foreign_elem_clone(kind, ftarget);
parts.clone_stmts.push(quote! {
{
let __fp: ::bstack_raii::WidePtr = __od.#fname;
#elem_clone
__od.#fname = __newfp;
}
});
}
if is_bstack_mut(&field.attrs) {
for m in foreign_mut_methods(vis, fname, "e!(#ftarget), on_disk_ty, kind, nullable) {
parts.accessors.push(m);
}
}
Ok(parts)
}
pub(crate) fn vec_field(
ctx: &FieldCtx,
opt_inner: &Type,
vinfo: VecInfo,
nullable: bool,
) -> syn::Result<FieldParts> {
let &FieldCtx {
vis,
fname,
field,
kind,
on_disk_ty,
type_params,
const_params,
..
} = ctx;
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
let elem = &vinfo.elem;
parts
.on_disk_fields
.push(quote!(#fname: ::bstack_raii::VecDesc,));
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
if vinfo.is_string && kind != Kind::Pod {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0107] `String` is always POD; remove the ownership annotation",
));
}
if let Some(velem) = vec_inner(opt_inner)
&& let Some(ftarget) = foreign_inner(option_inner(velem).unwrap_or(velem))
{
let elem_nullable = option_inner(velem).is_some();
validate_foreign_target(
kind,
ftarget,
&field.ty,
"`Vec<Foreign<T>>`",
format_ident!("__bstack_foreign_vec_target_{}", fname),
!type_mentions_any(ftarget, type_params),
&mut parts.wrapper_defs,
)?;
let store = quote!(::bstack_raii::BStackVec::<::bstack_raii::WidePtr, __A>);
let field_loc = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk_ty, #fname) as u64
)?);
let field_ty = if elem_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<#ftarget>>)
} else {
quote!(::bstack_raii::Foreign<#ftarget>)
};
let acc_elem_ty = if elem_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<'__v, #ftarget>>)
} else {
quote!(::bstack_raii::Foreign<'__v, #ftarget>)
};
let from_ptr = if elem_nullable {
quote!(|__p: ::bstack_raii::WidePtr|
-> ::std::io::Result<#acc_elem_ty> {
if __p.offset().get() == 0 {
::std::result::Result::Ok(::core::option::Option::None)
} else {
let __repr =
::bstack_raii::registry::resolve_self_repr(__p, allocator.stack())?;
::std::result::Result::Ok(::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) }))
}
})
} else {
quote!(|__p: ::bstack_raii::WidePtr|
-> ::std::io::Result<#acc_elem_ty> {
let __repr =
::bstack_raii::registry::resolve_self_repr(__p, allocator.stack())?;
::std::result::Result::Ok(
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) })
})
};
let to_ptr = if elem_nullable {
quote!(|__f: #field_ty| match __f {
::core::option::Option::Some(__ff) =>
::bstack_raii::registry::home_relative_repr(__ff.repr(), allocator.stack()),
::core::option::Option::None => ::bstack_raii::WidePtr::NULL,
})
} else {
quote!(|__f: #field_ty|
::bstack_raii::registry::home_relative_repr(__f.repr(), allocator.stack()))
};
let (acc_ret, acc_body) = if nullable {
(
quote!(::core::option::Option<::std::vec::Vec<#acc_elem_ty>>),
quote!(match unsafe { #store::from_field_opt(::bstack_raii::NonNullOffset::from_field(#field_loc)?, allocator) }? {
::core::option::Option::Some(__v) => ::core::option::Option::Some(
__v.to_vec()?
.into_iter()
.map(#from_ptr)
.collect::<::std::io::Result<::std::vec::Vec<_>>>()?),
::core::option::Option::None => ::core::option::Option::None,
}),
)
} else {
(
quote!(::std::vec::Vec<#acc_elem_ty>),
quote!(unsafe { #store::from_field(::bstack_raii::NonNullOffset::from_field(#field_loc)?, allocator)? }
.to_vec()?
.into_iter()
.map(#from_ptr)
.collect::<::std::io::Result<::std::vec::Vec<_>>>()?),
)
};
parts.accessors.push(quote! {
#vis fn #getter<'__v, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__v __A,
) -> ::std::io::Result<#acc_ret> {
::std::result::Result::Ok(#acc_body)
}
});
let build = quote! {
let __ptrs: ::std::vec::Vec<::bstack_raii::WidePtr> =
__list.into_iter().map(#to_ptr).collect();
#store::from_slice(allocator, &__ptrs)?.descriptor()
};
let (param, prep) = if nullable {
(
quote!(#fname: ::core::option::Option<::std::vec::Vec<#field_ty>>,),
quote! {
let #fname: ::bstack_raii::VecDesc = match #fname {
::core::option::Option::Some(__list) => { #build }
::core::option::Option::None => ::core::default::Default::default(),
};
},
)
} else {
(
quote!(#fname: ::std::vec::Vec<#field_ty>,),
quote! {
let #fname: ::bstack_raii::VecDesc = { let __list = #fname; #build };
},
)
};
parts.ctor_params.push(param);
parts.ctor_preps.push(prep);
parts.ctor_inits.push(quote!(#fname,));
let elem_drop = foreign_elem_drop(kind, ftarget);
let drop_loop = if matches!(kind, Kind::Ref) {
quote!()
} else {
quote! {
for __fp in unsafe { #store::from_desc(__desc, allocator) }.to_vec()? { #elem_drop }
}
};
parts.drop_stmts.push(quote! {
{
let __desc: ::bstack_raii::VecDesc = __on_disk.#fname;
if !__desc.data_off.is_null() {
#drop_loop
unsafe { #store::from_desc(__desc, allocator) }.bstack_drop()?;
}
}
});
let elem_clone = foreign_elem_clone(kind, ftarget);
parts.clone_stmts.push(quote! {
{
let __srcdesc: ::bstack_raii::VecDesc = __od.#fname;
if !__srcdesc.data_off.is_null() {
let __src = unsafe { #store::from_desc(__srcdesc, allocator) }.to_vec()?;
let mut __new: ::std::vec::Vec<::bstack_raii::WidePtr> =
::std::vec::Vec::with_capacity(__src.len());
for __fp in __src {
#elem_clone
__new.push(__newfp);
}
__od.#fname = __plan.stage_bytevec(
allocator, ::bstack_raii::bytemuck::cast_slice(&__new))?;
}
}
});
let (dual_ty, wrap) = match kind {
Kind::Owned => (
quote!(::bstack_raii::ForeignOwned<'__mv, #ftarget>),
quote!(::bstack_raii::ForeignOwned::from_foreign(
::bstack_raii::Foreign::from_repr(__repr)
)),
),
Kind::Strong => (
quote!(::bstack_raii::ForeignRc<'__mv, #ftarget>),
quote!(::bstack_raii::ForeignRc::from_foreign(
::bstack_raii::Foreign::from_repr(__repr)
)),
),
Kind::Weak => (
quote!(::bstack_raii::ForeignWeak<'__mv, #ftarget>),
quote!(::bstack_raii::ForeignWeak::from_foreign(
::bstack_raii::Foreign::from_repr(__repr)
)),
),
_ => (
quote!(::bstack_raii::Foreign<'__mv, #ftarget>),
quote!(::bstack_raii::Foreign::from_repr(__repr)),
),
};
let leaf_ty = if elem_nullable {
quote!(::core::option::Option<#dual_ty>)
} else {
dual_ty.clone()
};
let push_expr = if elem_nullable {
quote! {
if __p.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr =
::bstack_raii::registry::resolve_self_repr(__p, __alloc.stack())?;
::core::option::Option::Some(unsafe { #wrap })
}
}
} else {
quote! {{
let __repr = ::bstack_raii::registry::resolve_self_repr(__p, __alloc.stack())?;
unsafe { #wrap }
}}
};
let build = quote! {{
let __vec = unsafe {
::bstack_raii::BStackVec::<::bstack_raii::WidePtr, __A>::from_desc(#cap, __alloc)
};
let __reprs = __vec.to_vec()?;
__vec.bstack_drop()?;
let mut __out: ::std::vec::Vec<#leaf_ty> =
::std::vec::Vec::with_capacity(__reprs.len());
for __p in __reprs {
__out.push(#push_expr);
}
__out
}};
let (mvt, mvr) = wrap_vec_move(quote!(::std::vec::Vec<#leaf_ty>), build, &cap, nullable);
parts.mv_types.push(mvt);
parts.mv_recon.push(mvr);
return Ok(parts);
}
if kind != Kind::Pod
&& let Some(velem) = vec_inner(opt_inner)
&& let Type::Array(_) = velem
{
let (dims, elem_ty, leaf_nullable) = array_shape(velem)?;
reject_nested_const_dims(&dims, const_params, &field.ty)?;
let total = dims_prod(&dims);
let elem_ts = quote!(#elem_ty);
let size_elem = quote!(::core::mem::size_of::<
<#elem_ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64);
let store = quote!(::bstack_raii::BStackVec::<u64, __A>);
let field_loc = quote!(::bstack_raii::checked_field_offset(
self.0.start(),
::core::mem::offset_of!(#on_disk_ty, #fname) as u64
)?);
let is_weak = kind == Kind::Weak;
let (ctrl_ty, ctrl_size) = (
quote!(<#elem_ty as ::bstack_raii::BStackWeakable>::Control),
quote!(::core::mem::size_of::<
<#elem_ty as ::bstack_raii::BStackWeakable>::Control>() as u64),
);
let vec_ty = match kind {
Kind::Owned => quote!(BStackBlockVec),
Kind::Strong => quote!(BStackStrongVec),
Kind::Weak => quote!(BStackWeakVec),
Kind::Ref => quote!(BStackRefVec),
_ => unreachable!(),
};
let view_leaf = if is_weak {
quote!(::core::option::Option<::bstack_raii::BStackRc<'__v, #elem_ty, __A>>)
} else if leaf_nullable {
quote!(::core::option::Option<#elem_ty>)
} else {
quote!(#elem_ty)
};
let view_ret = nested_ty(&dims, &view_leaf);
let view_read = |k: &Ident| {
if is_weak {
quote!({
let __o = __grp[#k];
if __o == 0 {
::core::option::Option::None
} else {
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__o, #ctrl_size)) };
let __wk = unsafe {
::bstack_raii::BStackWeak::<#elem_ty, __A>::from_raw(
__ctrl, allocator) };
let __up = __wk.upgrade()?;
let _ = __wk.into_raw();
__up
}
})
} else if leaf_nullable {
quote!({
let __o = __grp[#k];
if __o == 0 {
::core::option::Option::None
} else {
::core::option::Option::Some(
unsafe { <#elem_ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__o, #size_elem)) })
}
})
} else {
quote!(unsafe { <#elem_ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__grp[#k], #size_elem)) })
}
};
let build_body = nested_build(&dims, &view_leaf, &view_read);
let reshape = quote! {
let mut __out = ::std::vec::Vec::with_capacity(__flat.len() / (#total));
for __grp in __flat.chunks(#total) {
__out.push(#build_body);
}
__out
};
let (acc_ret, acc_map): (TokenStream, TokenStream) = if nullable {
(
quote!(::core::option::Option<::std::vec::Vec<#view_ret>>),
quote!(match unsafe { #store::from_field_opt(::bstack_raii::NonNullOffset::from_field(#field_loc)?, allocator) }? {
::core::option::Option::Some(__v) => {
let __flat = __v.to_vec()?;
::core::option::Option::Some({ #reshape })
}
::core::option::Option::None => ::core::option::Option::None,
}),
)
} else {
(
quote!(::std::vec::Vec<#view_ret>),
quote!({
let __flat = unsafe { #store::from_field(::bstack_raii::NonNullOffset::from_field(#field_loc)?, allocator)? }.to_vec()?;
#reshape
}),
)
};
parts.accessors.push(quote! {
#vis fn #getter<'__v, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__v __A,
) -> ::std::io::Result<#acc_ret> {
::std::result::Result::Ok(#acc_map)
}
});
let handle_base = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem_ty>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__ctor, #elem_ty, __A>),
Kind::Weak => quote!(::bstack_raii::BStackWeak<'__ctor, #elem_ty, __A>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem_ty>),
_ => unreachable!(),
};
let handle_leaf = if leaf_nullable {
quote!(::core::option::Option<#handle_base>)
} else {
handle_base.clone()
};
let param_ty = nested_ty(&dims, &handle_leaf);
let off_of = |h: &Ident| match kind {
Kind::Owned => quote!({
let __h = #h.into_inner();
::bstack_raii::BStackBlock::range(&__h).start()
}),
Kind::Strong => quote!({
let (__d, _c) = #h.into_raw();
__d.into_range().start()
}),
Kind::Weak => quote!(#h.into_raw().into_range().start()),
Kind::Ref => quote!(#h.into_range().start()),
_ => unreachable!(),
};
let leaf_write = |_k: &Ident, leaf: &Ident| {
if leaf_nullable {
let hh = format_ident!("__h");
let off = off_of(&hh);
quote!(__flat.push(match #leaf {
::core::option::Option::Some(#hh) => #off,
::core::option::Option::None => 0u64,
});)
} else {
let off = off_of(leaf);
quote!(__flat.push(#off);)
}
};
let consume_one = nested_consume(&dims, "e!(__a), &leaf_write);
let build_flat = quote! {
let mut __flat: ::std::vec::Vec<u64> = ::std::vec::Vec::new();
for __a in __list {
#consume_one
}
#store::from_slice(allocator, &__flat)?.descriptor()
};
let (param, prep) = if nullable {
(
quote!(#fname: ::core::option::Option<::std::vec::Vec<#param_ty>>,),
quote! {
let #fname: ::bstack_raii::VecDesc = match #fname {
::core::option::Option::Some(__list) => { #build_flat }
::core::option::Option::None => ::core::default::Default::default(),
};
},
)
} else {
(
quote!(#fname: ::std::vec::Vec<#param_ty>,),
quote! {
let #fname: ::bstack_raii::VecDesc = {
let __list = #fname;
#build_flat
};
},
)
};
parts.ctor_params.push(param);
parts.ctor_preps.push(prep);
parts.ctor_inits.push(quote!(#fname,));
let free_child = match kind {
Kind::Owned => quote!(unsafe { ::bstack_raii::OwnedRef::new(
::bstack_raii::BStackRef::<#elem_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem)))
}.bstack_drop(allocator)?;),
Kind::Strong => {
quote!(<#elem_ty as ::bstack_raii::BStackShared>::drop_strong_ref(
unsafe { ::bstack_raii::BStackRef::<#elem_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem)) },
allocator)?;)
}
Kind::Weak => quote!(unsafe { ::bstack_raii::WeakRef::<#elem_ty>::new(
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #ctrl_size)))
}.bstack_drop(allocator)?;),
Kind::Ref => quote!(),
_ => unreachable!(),
};
let free_children = if matches!(kind, Kind::Ref) {
quote!()
} else {
quote! {
for __off in unsafe { #store::from_desc(__desc, allocator) }.to_vec()? {
if __off != 0 { #free_child }
}
}
};
parts.drop_stmts.push(quote! {
{
let __desc: ::bstack_raii::VecDesc = __on_disk.#fname;
if !__desc.data_off.is_null() {
#free_children
unsafe { #store::from_desc(__desc, allocator) }.bstack_drop()?;
}
}
});
let clone_body = match kind {
Kind::Owned => quote! {
let __flat = unsafe { #store::from_desc(__srcdesc, allocator) }.to_vec()?;
let mut __new: ::std::vec::Vec<u64> =
::std::vec::Vec::with_capacity(__flat.len());
for __off in __flat {
if __off != 0 {
__new.push(
unsafe { <#elem_ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem)) }
.__bstack_clone_into(allocator, __plan)?.start());
} else {
__new.push(0u64);
}
}
__od.#fname = __plan.stage_bytevec(
allocator, ::bstack_raii::bytemuck::cast_slice(&__new))?;
},
Kind::Strong => quote! {
for __off in unsafe { #store::from_desc(__srcdesc, allocator) }.to_vec()? {
if __off != 0 {
__plan.bump_strong(unsafe {
::bstack_raii::BStackRef::<#elem_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem))
}, allocator)?;
}
}
__od.#fname = unsafe { #store::from_desc(__srcdesc, allocator) }
.clone_data_into(__plan)?;
},
Kind::Weak => quote! {
for __off in unsafe { #store::from_desc(__srcdesc, allocator) }.to_vec()? {
if __off != 0 { __plan.bump_weak(__off)?; }
}
__od.#fname = unsafe { #store::from_desc(__srcdesc, allocator) }
.clone_data_into(__plan)?;
},
Kind::Ref => quote! {
__od.#fname = unsafe { #store::from_desc(__srcdesc, allocator) }
.clone_data_into(__plan)?;
},
_ => unreachable!(),
};
parts.clone_stmts.push(quote! {
{
let __srcdesc: ::bstack_raii::VecDesc = __od.#fname;
if !__srcdesc.data_off.is_null() {
#clone_body
}
}
});
let (mvt, mvr) = block_vec_move(&cap, &elem_ts, vec_ty, nullable);
if !matches!(kind, Kind::Ref) {
parts
.ctor_handback
.push(mv_ty_as_ctor("e!({ let #cap = #fname; #mvr })));
parts.ctor_handback_ty.push(mv_ty_as_ctor(&mvt));
}
parts.mv_types.push(mvt);
parts.mv_recon.push(mvr);
return Ok(parts);
}
let (drop_s, acc, ctor, mv) = match kind {
Kind::Embed => {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0501] cannot #[embed] a `Vec` / `String`; embed a `#[bstack_block]` type",
));
}
Kind::Pod => (
vec_drop_stmt(fname, elem, nullable),
vec_accessor(vis, fname, elem, on_disk_ty, nullable),
vec_ctor(fname, &vinfo, nullable),
vec_move(&cap, elem, nullable),
),
Kind::Owned => (
block_vec_drop_stmt(fname, quote!(BStackBlockVec), elem, nullable),
block_vec_accessor(
vis,
fname,
elem,
on_disk_ty,
quote!(BStackBlockVec),
nullable,
),
block_vec_ctor(
fname,
elem,
quote!(BStackBlockVec),
quote!(::bstack_raii::BStackOwned<#elem>),
nullable,
true,
),
block_vec_move(&cap, elem, quote!(BStackBlockVec), nullable),
),
Kind::Strong => (
block_vec_drop_stmt(fname, quote!(BStackStrongVec), elem, nullable),
block_vec_accessor(
vis,
fname,
elem,
on_disk_ty,
quote!(BStackStrongVec),
nullable,
),
block_vec_ctor(
fname,
elem,
quote!(BStackStrongVec),
quote!(::bstack_raii::BStackRc<'__ctor, #elem, __A>),
nullable,
true,
),
block_vec_move(&cap, elem, quote!(BStackStrongVec), nullable),
),
Kind::Weak => (
block_vec_drop_stmt(fname, quote!(BStackWeakVec), elem, nullable),
block_vec_accessor(
vis,
fname,
elem,
on_disk_ty,
quote!(BStackWeakVec),
nullable,
),
block_vec_ctor(
fname,
elem,
quote!(BStackWeakVec),
quote!(::bstack_raii::BStackWeak<'__ctor, #elem, __A>),
nullable,
true,
),
block_vec_move(&cap, elem, quote!(BStackWeakVec), nullable),
),
Kind::Ref => (
block_vec_drop_stmt(fname, quote!(BStackRefVec), elem, nullable),
block_vec_accessor(vis, fname, elem, on_disk_ty, quote!(BStackRefVec), nullable),
block_vec_ctor(
fname,
elem,
quote!(BStackRefVec),
quote!(::bstack_raii::BStackRef<#elem>),
nullable,
false,
),
block_vec_move(&cap, elem, quote!(BStackRefVec), nullable),
),
};
parts.drop_stmts.push(drop_s);
parts.clone_stmts.push(vec_clone_stmt(fname, kind, elem));
parts.accessors.push(acc);
let (param, prep, init) = ctor;
parts.ctor_params.push(param);
parts.ctor_preps.push(prep);
parts.ctor_inits.push(init);
let (mv_ty, mv_rc) = mv;
if matches!(kind, Kind::Owned | Kind::Strong | Kind::Weak) {
parts
.ctor_handback
.push(mv_ty_as_ctor("e!({ let #cap = #fname; #mv_rc })));
parts.ctor_handback_ty.push(mv_ty_as_ctor(&mv_ty));
}
parts.mv_types.push(mv_ty);
parts.mv_recon.push(mv_rc);
Ok(parts)
}
pub(crate) fn vec_array_field(
ctx: &FieldCtx,
opt_inner: &Type,
nullable: bool,
) -> syn::Result<Option<FieldParts>> {
let &FieldCtx {
vis,
fname,
field,
kind,
on_disk_ty,
const_params,
..
} = ctx;
let Type::Array(_) = opt_inner else {
return Ok(None);
};
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
let (dims, leaf, leaf_nullable) = array_shape(opt_inner)?;
reject_nested_const_dims(&dims, const_params, &field.ty)?;
let leaf_vinfo = if is_str(leaf) {
Some(VecInfo {
elem: quote!(u8),
is_string: true,
})
} else {
vec_info(leaf)
};
if let Some(leaf_vinfo) = leaf_vinfo {
check_container_nesting(leaf)?;
if nullable {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0110] a whole-array `Option<[Vec<T>; N]>` is not supported; use \
`[Option<Vec<T>>; N]` for per-element nullability",
));
}
if leaf_vinfo.is_string && kind != Kind::Pod {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0107] `String` is always POD; remove the ownership annotation",
));
}
if kind == Kind::Embed {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0501] cannot #[embed] a `Vec` / `String`; embed a `#[bstack_block]` type",
));
}
let total = dims_prod(&dims);
let elem = &leaf_vinfo.elem;
let is_string = leaf_vinfo.is_string;
let vec_ty = match kind {
Kind::Pod => quote!(BStackVec),
Kind::Owned => quote!(BStackBlockVec),
Kind::Strong => quote!(BStackStrongVec),
Kind::Weak => quote!(BStackWeakVec),
Kind::Ref => quote!(BStackRefVec),
Kind::Embed => unreachable!(),
};
parts
.on_disk_fields
.push(quote!(#fname: [::bstack_raii::VecDesc; #total],));
let handle_lt = quote!(::bstack_raii::#vec_ty<'__v, #elem, __A>);
let acc_leaf = if leaf_nullable {
quote!(::core::option::Option<#handle_lt>)
} else {
handle_lt.clone()
};
let acc_ret = nested_ty(&dims, &acc_leaf);
let acc_read = |k: &Ident| {
let slot = quote!(
__base + (#k as u64) * (::core::mem::size_of::<::bstack_raii::VecDesc>() as u64));
if leaf_nullable {
quote!(unsafe { ::bstack_raii::#vec_ty::from_field_opt(::bstack_raii::NonNullOffset::from_field(#slot)?, allocator) }?)
} else {
quote!(unsafe { ::bstack_raii::#vec_ty::from_field(::bstack_raii::NonNullOffset::from_field(#slot)?, allocator) }?)
}
};
let acc_body = nested_build(&dims, &acc_leaf, &acc_read);
parts.accessors.push(quote! {
#vis fn #getter<'__v, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__v __A,
) -> ::std::io::Result<#acc_ret> {
let __base =
::bstack_raii::checked_field_offset(self.0.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?;
::std::result::Result::Ok(#acc_body)
}
});
let handle_ctor = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__ctor, #elem, __A>),
Kind::Weak => quote!(::bstack_raii::BStackWeak<'__ctor, #elem, __A>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem>),
_ => quote!(),
};
let ctor_leaf = match kind {
Kind::Pod if is_string => quote!(&str),
Kind::Pod => quote!(&[#elem]),
_ => quote!(::std::vec::Vec<#handle_ctor>),
};
let param_leaf = if leaf_nullable {
quote!(::core::option::Option<#ctor_leaf>)
} else {
ctor_leaf.clone()
};
let ctor_param_ty = nested_ty(&dims, ¶m_leaf);
parts.ctor_params.push(quote!(#fname: #ctor_param_ty,));
let desc_of = |b: &Ident| -> TokenStream {
match kind {
Kind::Pod => {
let data = if is_string {
quote!(#b.as_bytes())
} else {
quote!(#b)
};
quote!(::bstack_raii::BStackVec::<#elem, __A>::from_slice(
allocator, #data)?.descriptor())
}
Kind::Ref => quote!(::bstack_raii::#vec_ty::<#elem, __A>::from_handles(
allocator, #b)?.descriptor()),
_ => {
quote!(match ::bstack_raii::#vec_ty::<#elem, __A>::from_handles(allocator, #b) {
::core::result::Result::Ok(__v) => __v.descriptor(),
::core::result::Result::Err(__e) => {
::core::mem::drop(__e.value);
return ::core::result::Result::Err(::core::convert::Into::into(__e.source));
}
})
}
}
};
let ctor_write = |k: &Ident, leaf: &Ident| {
if leaf_nullable {
let inner = format_ident!("__vd");
let d = desc_of(&inner);
quote!({
__slots[#k] = match #leaf {
::core::option::Option::Some(#inner) => #d,
::core::option::Option::None =>
::core::default::Default::default(),
};
})
} else {
let d = desc_of(leaf);
quote!(__slots[#k] = #d;)
}
};
let flatten = nested_consume(&dims, "e!(#fname), &ctor_write);
parts.ctor_preps.push(quote! {
let #fname: [::bstack_raii::VecDesc; #total] = {
let mut __slots =
[<::bstack_raii::VecDesc as ::core::default::Default>::default();
#total];
#flatten
__slots
};
});
parts.ctor_inits.push(quote!(#fname,));
parts.drop_stmts.push(quote! {
{
let __descs: [::bstack_raii::VecDesc; #total] = __on_disk.#fname;
for __k in 0usize..(#total) {
if !__descs[__k].data_off.is_null() {
unsafe { ::bstack_raii::#vec_ty::<#elem, __A>::from_desc(
__descs[__k], allocator) }.bstack_drop()?;
}
}
}
});
let clone_expr = match kind {
Kind::Pod => quote!(unsafe { ::bstack_raii::BStackVec::<#elem, __A>::from_desc(
__sd, allocator) }.clone_data_into(__plan)?),
Kind::Owned => quote!(unsafe { ::bstack_raii::BStackBlockVec::<#elem, __A>::from_desc(
__sd, allocator) }.clone_into(__plan, |__er, __p| {
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(__er) }
.__bstack_clone_into(allocator, __p)
})?),
Kind::Strong => {
quote!(unsafe { ::bstack_raii::BStackStrongVec::<#elem, __A>::from_desc(
__sd, allocator) }.clone_into(__plan)?)
}
Kind::Weak => quote!(unsafe { ::bstack_raii::BStackWeakVec::<#elem, __A>::from_desc(
__sd, allocator) }.clone_into(__plan)?),
Kind::Ref => quote!(unsafe { ::bstack_raii::BStackRefVec::<#elem, __A>::from_desc(
__sd, allocator) }.clone_into(__plan)?),
Kind::Embed => unreachable!(),
};
parts.clone_stmts.push(quote! {
{
let mut __descs: [::bstack_raii::VecDesc; #total] = __od.#fname;
for __k in 0usize..(#total) {
let __sd: ::bstack_raii::VecDesc = __descs[__k];
if !__sd.data_off.is_null() {
__descs[__k] = #clone_expr;
}
}
__od.#fname = __descs;
}
});
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
let mv_handle = quote!(::bstack_raii::#vec_ty<'__mv, #elem, __A>);
let mv_leaf = if leaf_nullable {
quote!(::core::option::Option<#mv_handle>)
} else {
mv_handle.clone()
};
let mv_ty = nested_ty(&dims, &mv_leaf);
let mv_read = |k: &Ident| {
if leaf_nullable {
quote!({
let __d = #cap[#k];
if !__d.data_off.is_null() {
::core::option::Option::Some(
unsafe { ::bstack_raii::#vec_ty::from_desc(__d, __alloc) })
} else {
::core::option::Option::None
}
})
} else {
quote!(unsafe { ::bstack_raii::#vec_ty::from_desc(#cap[#k], __alloc) })
}
};
let mv_rc = nested_build(&dims, &mv_leaf, &mv_read);
if matches!(kind, Kind::Owned | Kind::Strong | Kind::Weak) {
parts
.ctor_handback
.push(mv_ty_as_ctor("e!({ let #cap = #fname; #mv_rc })));
parts.ctor_handback_ty.push(mv_ty_as_ctor(&mv_ty));
}
parts.mv_types.push(mv_ty);
parts.mv_recon.push(mv_rc);
return Ok(Some(parts));
}
Ok(None)
}
pub(crate) fn foreign_array_field(
ctx: &FieldCtx,
opt_inner: &Type,
nullable: bool,
) -> syn::Result<Option<FieldParts>> {
let &FieldCtx {
vis,
fname,
field,
kind,
on_disk_ty,
type_params,
const_params,
..
} = ctx;
let Type::Array(_) = opt_inner else {
return Ok(None);
};
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
let (adims, aleaf, aleaf_nullable) = array_shape(opt_inner)?;
if let Some(ftarget) = foreign_inner(aleaf) {
reject_nested_const_dims(&adims, const_params, &field.ty)?;
validate_foreign_target(
kind,
ftarget,
&field.ty,
"`[Foreign<T>; N]`",
format_ident!("__bstack_foreign_arr_target_{}", fname),
!type_mentions_any(ftarget, type_params),
&mut parts.wrapper_defs,
)?;
if nullable {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0111] a whole-array `Option<[Foreign<T>; N]>` is not supported; a null foreign \
element is a `Foreign` with offset 0, or use `[Option<Foreign<T>>; N]`",
));
}
let total = dims_prod(&adims);
let field_ty = quote!(::bstack_raii::Foreign<#ftarget>);
parts
.on_disk_fields
.push(quote!(#fname: [::bstack_raii::WidePtr; #total],));
let leaf_ty = if aleaf_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<'__f, #ftarget>>)
} else {
quote!(::bstack_raii::Foreign<'__f, #ftarget>)
};
let acc_ret = nested_ty(&adims, &leaf_ty);
let acc_read = |k: &Ident| {
if aleaf_nullable {
quote!({
let __p = __arr[#k];
if __p.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr = ::bstack_raii::registry::resolve_self_repr(__p, stack)?;
::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) })
}
})
} else {
quote!({
let __repr =
::bstack_raii::registry::resolve_self_repr(__arr[#k], stack)?;
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) }
})
}
};
let acc_body = nested_build(&adims, &leaf_ty, &acc_read);
parts.accessors.push(quote! {
#vis fn #getter<'__f>(
&self,
stack: &'__f ::bstack_raii::BStack,
) -> ::std::io::Result<#acc_ret> {
let mut __buf = ::std::vec![0u8; ::core::mem::size_of::<#on_disk_ty>()];
let __r = unsafe { ::bstack_raii::BStackRef::<Self>::from_range(self.0) };
let __od: #on_disk_ty = *__r.read_on_disk(stack, &mut __buf)?;
let __arr: [::bstack_raii::WidePtr; #total] = __od.#fname;
::std::result::Result::Ok(#acc_body)
}
});
let param_leaf = if aleaf_nullable {
quote!(::core::option::Option<#field_ty>)
} else {
field_ty.clone()
};
let param_ty = nested_ty(&adims, ¶m_leaf);
parts.ctor_params.push(quote!(#fname: #param_ty,));
let ctor_write = |k: &Ident, leaf: &Ident| {
if aleaf_nullable {
quote!(__slots[#k] = match #leaf {
::core::option::Option::Some(__f) =>
::bstack_raii::registry::home_relative_repr(
__f.repr(), allocator.stack()),
::core::option::Option::None => ::bstack_raii::WidePtr::NULL,
};)
} else {
quote!(__slots[#k] = ::bstack_raii::registry::home_relative_repr(
#leaf.repr(), allocator.stack());)
}
};
let flatten = nested_consume(&adims, "e!(#fname), &ctor_write);
parts.ctor_preps.push(quote! {
let #fname: [::bstack_raii::WidePtr; #total] = {
let mut __slots = [::bstack_raii::WidePtr::NULL; #total];
#flatten
__slots
};
});
parts.ctor_inits.push(quote!(#fname,));
let elem_drop = foreign_elem_drop(kind, ftarget);
let drop_body = if matches!(kind, Kind::Ref) {
quote!()
} else {
quote! {
let __arr: [::bstack_raii::WidePtr; #total] = __on_disk.#fname;
for __k in 0usize..(#total) {
let __fp = __arr[__k];
#elem_drop
}
}
};
parts.drop_stmts.push(quote! { { #drop_body } });
let elem_clone = foreign_elem_clone(kind, ftarget);
parts.clone_stmts.push(quote! {
{
let __arr: [::bstack_raii::WidePtr; #total] = __od.#fname;
let mut __narr: [::bstack_raii::WidePtr; #total] = __arr;
for __k in 0usize..(#total) {
let __fp = __arr[__k];
#elem_clone
__narr[__k] = __newfp;
}
__od.#fname = __narr;
}
});
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
let mv_leaf = if aleaf_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<'__mv, #ftarget>>)
} else {
quote!(::bstack_raii::Foreign<'__mv, #ftarget>)
};
parts.mv_types.push(nested_ty(&adims, &mv_leaf));
let mv_read = |k: &Ident| {
if aleaf_nullable {
quote!({
let __p = #cap[#k];
if __p.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr =
::bstack_raii::registry::resolve_self_repr(__p, __stack)?;
::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) })
}
})
} else {
quote!({
let __repr =
::bstack_raii::registry::resolve_self_repr(#cap[#k], __stack)?;
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) }
})
}
};
parts
.mv_recon
.push(nested_build(&adims, &mv_leaf, &mv_read));
return Ok(Some(parts));
}
Ok(None)
}
pub(crate) fn block_array_field(
ctx: &FieldCtx,
opt_inner: &Type,
nullable: bool,
) -> syn::Result<Option<FieldParts>> {
let &FieldCtx {
vis,
fname,
field,
kind,
on_disk_ty,
type_params,
const_params,
..
} = ctx;
if kind == Kind::Pod {
return Ok(None);
}
let Type::Array(_) = opt_inner else {
return Ok(None);
};
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
if nullable {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0105] a whole-array `Option<[T; N]>` is not supported; use `[Option<T>; N]` \
for per-element nullability",
));
}
let (dims, elem, elem_nullable) = array_shape(opt_inner)?;
reject_nested_const_dims(&dims, const_params, &field.ty)?;
let total = dims_prod(&dims);
if kind == Kind::Embed {
if elem_nullable {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0503] #[embed] does not support `Option`",
));
}
if is_bstack_mut(&field.attrs) {
return Err(Error::new_spanned(
field,
"[BSTACK0601] #[bstack_mut] is not yet supported on #[embed] fields",
));
}
let child = elem;
if !type_mentions_any(child, type_params) {
parts.wrapper_defs.push(quote! {
const _: fn() = || {
fn __assert_embeddable<__T: ::bstack_raii::__private::BStackEmbeddable>() {}
__assert_embeddable::<#child>();
};
});
}
let child_od = quote!(<#child as ::bstack_raii::BStackBlock>::OnDisk);
parts
.on_disk_fields
.push(quote!(#fname: [#child_od; #total],));
parts.drop_stmts.push(quote! {
{
let __base =
::bstack_raii::checked_field_offset(__range.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?;
let __step = ::core::mem::size_of::<#child_od>() as u64;
for __k in 0usize..(#total) {
let __embed = ::bstack_raii::BStackRange::new(
__base + (__k as u64) * __step, __step);
<#child>::__bstack_drop_children(allocator, __embed)?;
}
}
});
let acc_ret = nested_ty(&dims, "e!(#child));
let acc_read = |k: &Ident| {
quote!(unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__base + (#k as u64) * __step, __step)) })
};
let acc_body = nested_build(&dims, "e!(#child), &acc_read);
parts.accessors.push(quote! {
#vis fn #getter(&self) -> ::std::io::Result<#acc_ret> {
let __base =
::bstack_raii::checked_field_offset(self.0.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?;
let __step = ::core::mem::size_of::<#child_od>() as u64;
::std::result::Result::Ok(#acc_body)
}
});
let src_id = format_ident!("__embed_src_{}", fname);
let param_ty = nested_ty(&dims, "e!(::bstack_raii::BStackOwned<#child>));
parts.ctor_params.push(quote!(#fname: #param_ty,));
let cap_write = |k: &Ident, leaf: &Ident| {
quote! {
#src_id[#k] = {
let __h = #leaf.into_inner();
::bstack_raii::BStackBlock::range(&__h)
};
}
};
let flatten = nested_consume(&dims, "e!(#fname), &cap_write);
parts.ctor_preps.push(quote! {
let #src_id: [::bstack_raii::BStackRange; #total] = {
let mut #src_id = [::bstack_raii::BStackRange::new(0, 0); #total];
#flatten
#src_id
};
});
parts
.ctor_inits
.push(quote!(#fname: [<#child_od as ::bstack_raii::Zeroable>::zeroed(); #total],));
parts.ctor_post.push(quote! {
{
let __base =
::bstack_raii::checked_field_offset(__data.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?;
let __step = ::core::mem::size_of::<#child_od>() as u64;
for __k in 0usize..(#total) {
let __src = #src_id[__k];
allocator.stack().copy(
__src.start(), __base + (__k as u64) * __step, __step)?;
unsafe { ::bstack_raii::dealloc_range(allocator, __src)?; }
}
}
});
let cap = format_ident!("__cap_{}", fname);
let src = format_ident!("__embed_mv_src_{}", fname);
let leaf_ty = quote!(::bstack_raii::BStackOwned<#child>);
let nested = nested_ty(&dims, &leaf_ty);
let mv_read = |k: &Ident| {
quote! {{
let __cod = #src[#k];
let mut __slice =
__alloc.alloc(::core::mem::size_of::<#child_od>() as u64)?;
let __r = __slice.as_range();
if let ::std::result::Result::Err(__e) =
__slice.write_range(0, ::bstack_raii::bytemuck::bytes_of(&__cod))
{
let _ = __alloc.dealloc(__slice);
return ::std::result::Result::Err(__e);
}
unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(__r) })
}
}}
};
let build = nested_build(&dims, &leaf_ty, &mv_read);
parts.mv_caps.push(quote! {
let #src = __od.#fname;
let #cap: #nested = #build;
});
parts.mv_types.push(nested_ty(&dims, &leaf_ty));
parts.mv_recon.push(quote!(#cap));
let hb_read = |k: &Ident| {
quote!(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(#src_id[#k]) })
})
};
parts.ctor_handback.push(nested_build(
&dims,
"e!(::bstack_raii::BStackOwned<#child>),
&hb_read,
));
parts.ctor_handback_ty.push(nested_ty(
&dims,
"e!(::bstack_raii::BStackOwned<#child>),
));
parts.clone_stmts.push(quote! {
{
let __base =
::bstack_raii::checked_field_offset(__src.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?;
let __step = ::core::mem::size_of::<#child_od>() as u64;
let mut __arr: [#child_od; #total] = __od.#fname;
for __k in 0usize..(#total) {
let __child = unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
__base + (__k as u64) * __step, __step)) };
__arr[__k] =
__child.__bstack_clone_children_inplace(allocator, __plan)?;
}
__od.#fname = __arr;
}
});
return Ok(Some(parts));
}
parts.on_disk_fields.push(quote!(#fname: [u64; #total],));
let size_elem = quote! {
::core::mem::size_of::<<#elem as ::bstack_raii::BStackBlock>::OnDisk>() as u64
};
if kind == Kind::Weak {
let ctrl_ty = quote!(<#elem as ::bstack_raii::BStackWeakable>::Control);
let ctrl_size = quote!(::core::mem::size_of::<#ctrl_ty>() as u64);
parts.ctor_inits.push(quote!(#fname: [0u64; #total],));
let setter = format_ident!("set_{}", fname);
parts.setters.push(quote! {
#vis fn #setter<'__s, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__s __A,
index: usize,
weak: ::bstack_raii::BStackWeak<'__s, #elem, __A>,
) -> ::core::result::Result<
(),
::bstack_raii::ReplaceError<::bstack_raii::BStackWeak<'__s, #elem, __A>>,
> {
if index >= (#total) {
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(
::std::io::Error::new(
::std::io::ErrorKind::InvalidInput,
"array index out of bounds",
),
weak,
));
}
let __field = match ::bstack_raii::NonNullOffset::from_field(
self.0.start()
+ ::core::mem::offset_of!(#on_disk_ty, #fname) as u64
+ (index as u64) * 8,
) {
::core::result::Result::Ok(__f) => __f,
::core::result::Result::Err(__e) => {
return ::core::result::Result::Err(::bstack_raii::ReplaceError::recovered(__e, weak));
}
};
unsafe { ::bstack_raii::BStackWeakable::set_weak_field(allocator, __field, weak) }
}
});
let leaf_ty = quote!(::core::option::Option<::bstack_raii::BStackRc<'__u, #elem, __A>>);
let acc_ret = nested_ty(&dims, &leaf_ty);
let acc_read = |k: &Ident| {
quote!(unsafe { ::bstack_raii::BStackWeakable::upgrade_weak_field(
allocator, ::bstack_raii::NonNullOffset::from_field(__base + (#k as u64) * 8)?)? })
};
let acc_body = nested_build(&dims, &leaf_ty, &acc_read);
parts.accessors.push(quote! {
#vis fn #getter<'__u, __A: ::bstack_raii::BStackRaiiAllocator>(
&self,
allocator: &'__u __A,
) -> ::std::io::Result<#acc_ret> {
let __base =
::bstack_raii::checked_field_offset(self.0.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?;
::std::result::Result::Ok(#acc_body)
}
});
parts.drop_stmts.push(quote! {
{
let __offs: [u64; #total] = __on_disk.#fname;
for __off in __offs {
if __off != 0 {
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #ctrl_size))
};
unsafe { ::bstack_raii::WeakRef::<#elem>::new(__ctrl) }.bstack_drop(allocator)?;
}
}
}
});
parts.clone_stmts.push(quote! {
{
let __offs: [u64; #total] = __od.#fname;
for __off in __offs {
if __off != 0 {
__plan.bump_weak(__off)?;
}
}
}
});
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
let mv_leaf_ty =
quote!(::core::option::Option<::bstack_raii::BStackWeak<'__mv, #elem, __A>>);
parts.mv_types.push(nested_ty(&dims, &mv_leaf_ty));
let mv_read = |k: &Ident| {
quote! {{
let __off = #cap[#k];
if __off == 0 {
::core::option::Option::None
} else {
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #ctrl_size))
};
::core::option::Option::Some(unsafe {
::bstack_raii::BStackWeak::from_raw(__ctrl, __alloc)
})
}
}}
};
parts
.mv_recon
.push(nested_build(&dims, &mv_leaf_ty, &mv_read));
return Ok(Some(parts));
}
let leaf_view = if elem_nullable {
quote!(::core::option::Option<#elem>)
} else {
quote!(#elem)
};
let acc_ret = nested_ty(&dims, &leaf_view);
let acc_read = |k: &Ident| {
if elem_nullable {
quote!({
let __o = __offs[#k];
if __o == 0 {
::core::option::Option::None
} else {
::core::option::Option::Some(
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__o, #size_elem)) })
}
})
} else {
quote!(unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__offs[#k], #size_elem)) })
}
};
let acc_body = nested_build(&dims, &leaf_view, &acc_read);
parts.accessors.push(quote! {
#vis fn #getter(
&self,
stack: &::bstack_raii::BStack,
) -> ::std::io::Result<#acc_ret> {
let mut __buf = ::std::vec![0u8; ::core::mem::size_of::<#on_disk_ty>()];
let __r = unsafe { ::bstack_raii::BStackRef::<Self>::from_range(self.0) };
let __od: #on_disk_ty = *__r.read_on_disk(stack, &mut __buf)?;
let __offs: [u64; #total] = __od.#fname;
::std::result::Result::Ok(#acc_body)
}
});
let handle_ty = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__ctor, #elem, __A>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem>),
_ => unreachable!(),
};
let off_of = |h: &Ident| match kind {
Kind::Owned => quote!({
let __h = #h.into_inner();
::bstack_raii::BStackBlock::range(&__h).start()
}),
Kind::Strong => quote!({
let (__d, _) = #h.into_raw();
__d.into_range().start()
}),
Kind::Ref => quote!(#h.into_range().start()),
_ => unreachable!(),
};
let ctor_leaf_ty = if elem_nullable {
quote!(::core::option::Option<#handle_ty>)
} else {
quote!(#handle_ty)
};
let ctor_param_ty = nested_ty(&dims, &ctor_leaf_ty);
parts.ctor_params.push(quote!(#fname: #ctor_param_ty,));
let ctor_write = |k: &Ident, leaf: &Ident| {
if elem_nullable {
let h = format_ident!("__handle");
let off = off_of(&h);
quote! {
__a[#k] = match #leaf {
::core::option::Option::Some(#h) => #off,
::core::option::Option::None => 0u64,
};
}
} else {
let off = off_of(leaf);
quote!(__a[#k] = #off;)
}
};
let flatten = nested_consume(&dims, "e!(#fname), &ctor_write);
parts.ctor_preps.push(quote! {
let #fname: [u64; #total] = {
let mut __a = [0u64; #total];
#flatten
__a
};
});
parts.ctor_inits.push(quote!(#fname,));
let per_teardown = match kind {
Kind::Owned => quote! {
unsafe { ::bstack_raii::OwnedRef::new(
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem)))
}.bstack_drop(allocator)?;
},
Kind::Strong => quote! {
<#elem as ::bstack_raii::BStackShared>::drop_strong_ref(unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem))
}, allocator)?;
},
_ => quote!(),
};
if kind != Kind::Ref {
parts.drop_stmts.push(quote! {
{
let __offs: [u64; #total] = __on_disk.#fname;
for __off in __offs {
if __off != 0 { #per_teardown }
}
}
});
}
match kind {
Kind::Owned => parts.clone_stmts.push(quote! {
{
let mut __arr: [u64; #total] = __od.#fname;
for __k in 0usize..(#total) {
let __off = __arr[__k];
if __off != 0 {
let __child = unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem)) };
__arr[__k] =
__child.__bstack_clone_into(allocator, __plan)?.start();
}
}
__od.#fname = __arr;
}
}),
Kind::Strong => parts.clone_stmts.push(quote! {
{
let __offs: [u64; #total] = __od.#fname;
for __off in __offs {
if __off != 0 {
let __child = unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem))
};
__plan.bump_strong(__child, allocator)?;
}
}
}
}),
_ => {}
}
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
let (mv_leaf, build_one): (TokenStream, TokenStream) = match kind {
Kind::Owned => (
quote!(::bstack_raii::BStackOwned<#elem>),
quote!(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem)) })
}),
),
Kind::Ref => (
quote!(::bstack_raii::BStackRef<#elem>),
quote!(unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem))
}),
),
Kind::Strong => (
quote!(::bstack_raii::BStackRc<'__mv, #elem, __A>),
quote!({
let __data = unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #size_elem))
};
let (__d, __c) =
<#elem as ::bstack_raii::BStackShared>::strong_parts(__data, __alloc)?;
unsafe { ::bstack_raii::BStackRc::from_raw(__d, __c, __alloc) }
}),
),
_ => unreachable!(),
};
let mv_leaf_ty = if elem_nullable {
quote!(::core::option::Option<#mv_leaf>)
} else {
mv_leaf.clone()
};
let mv_ty = nested_ty(&dims, &mv_leaf_ty);
let mv_read = |k: &Ident| {
if elem_nullable {
quote! {{
let __off = #cap[#k];
if __off == 0 {
::core::option::Option::None
} else {
::core::option::Option::Some(#build_one)
}
}}
} else {
quote! {{
let __off = #cap[#k];
#build_one
}}
}
};
let mv_rc = nested_build(&dims, &mv_leaf_ty, &mv_read);
if matches!(kind, Kind::Owned | Kind::Strong) {
parts
.ctor_handback
.push(mv_ty_as_ctor("e!({ let #cap = #fname; #mv_rc })));
parts.ctor_handback_ty.push(mv_ty_as_ctor(&mv_ty));
}
parts.mv_types.push(mv_ty);
parts.mv_recon.push(mv_rc);
if is_bstack_mut(&field.attrs) {
for m in array_mut_methods(
vis,
fname,
"e!(#elem),
on_disk_ty,
kind,
&dims,
&total,
&size_elem,
elem_nullable,
) {
parts.accessors.push(m);
}
}
Ok(Some(parts))
}
pub(crate) fn foreign_tuple_field(
ctx: &FieldCtx,
inner_ty: &Type,
nullable: bool,
) -> syn::Result<Option<FieldParts>> {
let &FieldCtx {
vis,
name,
fname,
field,
kind,
on_disk_ty,
..
} = ctx;
let Type::Tuple(tup) = inner_ty else {
return Ok(None);
};
if !tup
.elems
.iter()
.any(|e| foreign_inner(option_inner(e).unwrap_or(e)).is_some())
{
return Ok(None);
}
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
match kind {
Kind::Owned | Kind::Strong | Kind::Weak | Kind::Ref => {}
Kind::Pod => {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0302] a tuple containing a `Foreign` needs an ownership annotation \
(`#[bstack_owned/strong/weak/ref]`) naming the foreign elements' kind",
));
}
Kind::Embed => {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0502] cannot #[embed] a tuple",
));
}
}
if nullable {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0106] a whole-tuple `Option<(..)>` is not supported; make the individual \
elements nullable instead",
));
}
let mut is_foreign = Vec::with_capacity(tup.elems.len());
let mut ftargets: Vec<Option<&Type>> = Vec::with_capacity(tup.elems.len());
let mut nulls = Vec::with_capacity(tup.elems.len());
for e in &tup.elems {
let inner = option_inner(e).unwrap_or(e);
if let Some(ft) = foreign_inner(inner) {
reject_bad_foreign_target(ft, &field.ty, "a `Foreign` tuple element")?;
is_foreign.push(true);
ftargets.push(Some(ft));
nulls.push(option_inner(e).is_some());
} else {
is_foreign.push(false);
ftargets.push(None);
nulls.push(false);
parts.pod_types.push(e.clone());
}
}
let n = tup.elems.len();
let idx: Vec<syn::Index> = (0..n).map(syn::Index::from).collect();
let mk_tuple_ty = |lt: Option<&syn::Lifetime>| -> TokenStream {
let elems: Vec<TokenStream> = (0..n)
.map(|i| {
if is_foreign[i] {
let ft = ftargets[i].unwrap();
let f = match lt {
Some(l) => quote!(::bstack_raii::Foreign<#l, #ft>),
None => quote!(::bstack_raii::Foreign<#ft>),
};
if nulls[i] {
quote!(::core::option::Option<#f>)
} else {
f
}
} else {
let e = &tup.elems[i];
quote!(#e)
}
})
.collect();
quote!(( #(#elems,)* ))
};
let lt_f = syn::Lifetime::new("'__f", Span::call_site());
let lt_mv = syn::Lifetime::new("'__mv", Span::call_site());
let pub_tuple_ty = mk_tuple_ty(None);
let acc_tuple_ty = mk_tuple_ty(Some(<_f));
let mv_tuple_ty = mk_tuple_ty(Some(<_mv));
let wrapper = format_ident!("__BstackFTup_{}_{}", name, fname);
let welem: Vec<TokenStream> = tup
.elems
.iter()
.enumerate()
.map(|(i, e)| {
if is_foreign[i] {
quote!(::bstack_raii::WidePtr)
} else {
quote!(#e)
}
})
.collect();
parts.wrapper_defs.push(quote! {
#[repr(C, packed)]
#[derive(::core::clone::Clone, ::core::marker::Copy)]
#[doc(hidden)]
#vis struct #wrapper( #(#welem),* );
unsafe impl ::bstack_raii::Zeroable for #wrapper {}
unsafe impl ::bstack_raii::Pod for #wrapper {}
});
parts.on_disk_fields.push(quote!(#fname: #wrapper,));
let acc_elems: Vec<TokenStream> = (0..n)
.map(|i| {
let ix = &idx[i];
if is_foreign[i] {
let ft = ftargets[i].unwrap();
if nulls[i] {
quote!(if __w.#ix.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr =
::bstack_raii::registry::resolve_self_repr(__w.#ix, stack)?;
::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ft>::from_repr(__repr) })
})
} else {
quote!({
let __repr =
::bstack_raii::registry::resolve_self_repr(__w.#ix, stack)?;
unsafe { ::bstack_raii::Foreign::<#ft>::from_repr(__repr) }
})
}
} else {
quote!(__w.#ix)
}
})
.collect();
parts.accessors.push(quote! {
#vis fn #getter<'__f>(
&self,
stack: &'__f ::bstack_raii::BStack,
) -> ::std::io::Result<#acc_tuple_ty> {
let mut __buf = ::std::vec![0u8; ::core::mem::size_of::<#on_disk_ty>()];
let __r = unsafe { ::bstack_raii::BStackRef::<Self>::from_range(self.0) };
let __od: #on_disk_ty = *__r.read_on_disk(stack, &mut __buf)?;
let __w = __od.#fname;
::std::result::Result::Ok(( #(#acc_elems,)* ))
}
});
let ctor_elems: Vec<TokenStream> = (0..n)
.map(|i| {
let ix = &idx[i];
if is_foreign[i] {
if nulls[i] {
quote!(match #fname.#ix {
::core::option::Option::Some(__f) =>
::bstack_raii::registry::home_relative_repr(
__f.repr(), allocator.stack()),
::core::option::Option::None => ::bstack_raii::WidePtr::NULL,
})
} else {
quote!(::bstack_raii::registry::home_relative_repr(
#fname.#ix.repr(), allocator.stack()))
}
} else {
quote!(#fname.#ix)
}
})
.collect();
parts.ctor_params.push(quote!(#fname: #pub_tuple_ty,));
parts
.ctor_preps
.push(quote!(let #fname: #wrapper = #wrapper( #(#ctor_elems),* );));
parts.ctor_inits.push(quote!(#fname,));
let mut tup_drops = Vec::new();
let mut tup_clones = Vec::new();
for i in 0..n {
if !is_foreign[i] {
continue;
}
let ix = &idx[i];
let ft = ftargets[i].unwrap();
let elem_drop = foreign_elem_drop(kind, ft);
tup_drops.push(quote! {
{
let __fp: ::bstack_raii::WidePtr = __w.#ix;
#elem_drop
}
});
let elem_clone = foreign_elem_clone(kind, ft);
tup_clones.push(quote! {
{
let __fp: ::bstack_raii::WidePtr = __w.#ix;
#elem_clone
__w.#ix = __newfp;
}
});
}
if !matches!(kind, Kind::Ref) {
parts.drop_stmts.push(quote! {
{
let __w = __on_disk.#fname;
#(#tup_drops)*
}
});
parts.clone_stmts.push(quote! {
{
let mut __w = __od.#fname;
#(#tup_clones)*
__od.#fname = __w;
}
});
}
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
parts.mv_types.push(quote!(#mv_tuple_ty));
let mv_elems: Vec<TokenStream> = (0..n)
.map(|i| {
let ix = &idx[i];
if is_foreign[i] {
let ft = ftargets[i].unwrap();
if nulls[i] {
quote!(if #cap.#ix.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr =
::bstack_raii::registry::resolve_self_repr(#cap.#ix, __stack)?;
::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ft>::from_repr(__repr) })
})
} else {
quote!({
let __repr =
::bstack_raii::registry::resolve_self_repr(#cap.#ix, __stack)?;
unsafe { ::bstack_raii::Foreign::<#ft>::from_repr(__repr) }
})
}
} else {
quote!(#cap.#ix)
}
})
.collect();
parts.mv_recon.push(quote!(( #(#mv_elems,)* )));
Ok(Some(parts))
}
pub(crate) fn pod_tuple_field(ctx: &FieldCtx, inner_ty: &Type) -> syn::Result<Option<FieldParts>> {
let &FieldCtx {
vis,
name,
fname,
field,
kind,
on_disk_ty,
..
} = ctx;
if kind != Kind::Pod {
return Ok(None);
}
let Type::Tuple(tup) = inner_ty else {
return Ok(None);
};
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
let elems: Vec<&Type> = tup.elems.iter().collect();
let wrapper = format_ident!("__BstackTup_{}_{}", name, fname);
let idx: Vec<syn::Index> = (0..elems.len()).map(syn::Index::from).collect();
parts.wrapper_defs.push(quote! {
#[repr(C, packed)]
#[derive(::core::clone::Clone, ::core::marker::Copy)]
#[doc(hidden)]
#vis struct #wrapper( #(#elems),* );
unsafe impl ::bstack_raii::Zeroable for #wrapper {}
unsafe impl ::bstack_raii::Pod for #wrapper {}
});
parts.pod_types.extend(elems.iter().map(|t| (*t).clone()));
parts.on_disk_fields.push(quote!(#fname: #wrapper,));
parts.accessors.push(quote! {
#vis fn #getter(
&self,
stack: &::bstack_raii::BStack,
) -> ::std::io::Result<#inner_ty> {
let mut __buf = ::std::vec![0u8; ::core::mem::size_of::<#on_disk_ty>()];
let __r = unsafe { ::bstack_raii::BStackRef::<Self>::from_range(self.0) };
let __od: #on_disk_ty = *__r.read_on_disk(stack, &mut __buf)?;
let __w = __od.#fname;
::std::result::Result::Ok(( #(__w.#idx,)* ))
}
});
parts.ctor_params.push(quote!(#fname: #inner_ty,));
parts
.ctor_preps
.push(quote!(let #fname: #wrapper = #wrapper( #(#fname.#idx),* );));
parts.ctor_inits.push(quote!(#fname,));
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
parts.mv_types.push(quote!(#inner_ty));
parts.mv_recon.push(quote!(( #(#cap.#idx,)* )));
if is_bstack_mut(&field.attrs) {
let setter = format_ident!("set_{}", fname);
let idx2 = idx.clone();
parts.accessors.push(quote! {
#vis fn #setter(
&self,
stack: &::bstack_raii::BStack,
value: #inner_ty,
) -> ::std::io::Result<()> {
let __w: #wrapper = #wrapper( #(value.#idx2),* );
let __off = self.0.start()
+ ::core::mem::offset_of!(#on_disk_ty, #fname) as u64;
stack.set(__off, ::bstack_raii::bytemuck::bytes_of(&__w))
}
});
}
Ok(Some(parts))
}
pub(crate) fn embed_field(
ctx: &FieldCtx,
inner_ty: &Type,
nullable: bool,
) -> syn::Result<Option<FieldParts>> {
let &FieldCtx {
vis,
fname,
field,
kind,
on_disk_ty,
type_params,
..
} = ctx;
if kind != Kind::Embed {
return Ok(None);
}
let mut parts = FieldParts::default();
let getter = format_ident!("get_{}", fname);
if let Type::Tuple(_) = inner_ty {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0502] cannot #[embed] a tuple — embed a `#[bstack_block]` / `#[bstack_enum]` type",
));
}
if nullable {
return Err(Error::new_spanned(
&field.ty,
"[BSTACK0503] #[embed] does not support `Option`",
));
}
if is_bstack_mut(&field.attrs) {
return Err(Error::new_spanned(
field,
"[BSTACK0601] #[bstack_mut] is not yet supported on #[embed] fields",
));
}
let child = inner_ty;
if !type_mentions_any(child, type_params) {
parts.wrapper_defs.push(quote! {
const _: fn() = || {
fn __assert_embeddable<__T: ::bstack_raii::__private::BStackEmbeddable>() {}
__assert_embeddable::<#child>();
};
});
}
let child_od = quote!(<#child as ::bstack_raii::BStackBlock>::OnDisk);
parts.on_disk_fields.push(quote!(#fname: #child_od,));
parts.drop_stmts.push(quote! {
{
let __embed = ::bstack_raii::BStackRange::new(
::bstack_raii::checked_field_offset(__range.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?,
::core::mem::size_of::<#child_od>() as u64,
);
<#child>::__bstack_drop_children(allocator, __embed)?;
}
});
parts.accessors.push(quote! {
#vis fn #getter(&self) -> ::std::io::Result<#child> {
::std::result::Result::Ok(unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
::bstack_raii::checked_field_offset(self.0.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?,
::core::mem::size_of::<#child_od>() as u64,
),
) })
}
});
let src_id = format_ident!("__embed_src_{}", fname);
parts
.ctor_params
.push(quote!(#fname: ::bstack_raii::BStackOwned<#child>,));
parts.ctor_preps.push(quote! {
let #src_id = {
let __h = #fname.into_inner();
::bstack_raii::BStackBlock::range(&__h)
};
});
parts
.ctor_inits
.push(quote!(#fname: <#child_od as ::bstack_raii::Zeroable>::zeroed(),));
parts.ctor_post.push(quote! {
{
allocator.stack().copy(
#src_id.start(),
::bstack_raii::checked_field_offset(__data.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?,
::core::mem::size_of::<#child_od>() as u64,
)?;
unsafe { ::bstack_raii::dealloc_range(allocator, #src_id)?; }
}
});
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote! {
let #cap: ::bstack_raii::BStackOwned<#child> = {
let __cod = __od.#fname;
let mut __slice =
__alloc.alloc(::core::mem::size_of::<#child_od>() as u64)?;
let __r = __slice.as_range();
if let ::std::result::Result::Err(__e) =
__slice.write_range(0, ::bstack_raii::bytemuck::bytes_of(&__cod))
{
let _ = __alloc.dealloc(__slice);
return ::std::result::Result::Err(__e);
}
unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(__r) },
)
}
};
});
parts
.mv_types
.push(quote!(::bstack_raii::BStackOwned<#child>));
parts.mv_recon.push(quote!(#cap));
parts.ctor_handback.push(quote! {
unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(#src_id) },
)
}
});
parts
.ctor_handback_ty
.push(quote!(::bstack_raii::BStackOwned<#child>));
parts.clone_stmts.push(quote! {
{
let __child = unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
::bstack_raii::checked_field_offset(__src.start(), ::core::mem::offset_of!(#on_disk_ty, #fname) as u64)?,
::core::mem::size_of::<#child_od>() as u64,
),
) };
__od.#fname =
__child.__bstack_clone_children_inplace(allocator, __plan)?;
}
});
Ok(Some(parts))
}
pub(crate) fn scalar_field(
ctx: &FieldCtx,
inner_ty: &Type,
nullable: bool,
) -> syn::Result<FieldParts> {
let &FieldCtx {
vis,
fname,
field,
kind,
on_disk_ty,
..
} = ctx;
let mut parts = FieldParts::default();
match kind {
Kind::Pod => {
parts.on_disk_fields.push(quote!(#fname: #inner_ty,));
parts.pod_types.push(inner_ty.clone());
}
_ => parts.on_disk_fields.push(quote!(#fname: u64,)),
}
match kind {
Kind::Owned => parts.drop_stmts.push(child_range_stmt(
fname,
inner_ty,
nullable,
quote!(unsafe { ::bstack_raii::OwnedRef::new(__child) }.bstack_drop(allocator)?;),
)),
Kind::Strong => parts.drop_stmts.push(child_range_stmt(
fname,
inner_ty,
nullable,
quote!(<#inner_ty as ::bstack_raii::BStackShared>::drop_strong_ref(__child, allocator)?;),
)),
Kind::Weak => parts.drop_stmts.push(weak_drop_stmt(fname, inner_ty)),
Kind::Ref | Kind::Pod | Kind::Embed => {}
}
if let Some(cs) = clone_field_stmt(fname, inner_ty, kind) {
parts.clone_stmts.push(cs);
}
parts
.accessors
.push(accessor(vis, fname, inner_ty, on_disk_ty, kind, nullable));
parts
.accessors
.push(raw_slice_accessor(vis, fname, inner_ty, on_disk_ty, kind));
if is_bstack_mut(&field.attrs) {
match kind {
Kind::Pod => {
parts.accessors.push(set_accessor(
vis, fname, inner_ty, on_disk_ty, kind, nullable,
));
}
Kind::Ref => {
parts.accessors.push(set_accessor(
vis, fname, inner_ty, on_disk_ty, kind, nullable,
));
parts.accessors.push(replace_accessor(
vis, fname, inner_ty, on_disk_ty, kind, nullable,
));
}
Kind::Owned | Kind::Strong => {
parts.accessors.push(replace_accessor(
vis, fname, inner_ty, on_disk_ty, kind, nullable,
));
}
Kind::Weak => {}
Kind::Embed => {
return Err(Error::new_spanned(
field,
"[BSTACK0601] #[bstack_mut] is not yet supported on #[embed] fields",
));
}
}
}
if kind == Kind::Weak {
parts.ctor_inits.push(quote!(#fname: 0u64,));
parts
.setters
.push(weak_setter(vis, fname, inner_ty, on_disk_ty));
} else {
let (param, prep, init) = ctor_field(fname, inner_ty, kind, nullable);
parts.ctor_params.push(param);
parts.ctor_preps.push(prep);
parts.ctor_inits.push(init);
}
let cap = format_ident!("__cap_{}", fname);
parts.mv_caps.push(quote!(let #cap = __od.#fname;));
let (mv_ty, mv_rc) = move_field(&cap, inner_ty, kind, nullable);
if matches!(kind, Kind::Owned | Kind::Strong) {
let base = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#inner_ty>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__ctor, #inner_ty, __A>),
_ => unreachable!(),
};
let hb_ty = if nullable {
quote!(::core::option::Option<#base>)
} else {
base
};
parts
.ctor_handback
.push(mv_ty_as_ctor("e!({ let #cap = #fname; #mv_rc })));
parts.ctor_handback_ty.push(hb_ty);
}
parts.mv_types.push(mv_ty);
parts.mv_recon.push(mv_rc);
Ok(parts)
}
pub(crate) fn pod_aggregate_variant(
ctx: &VariantCtx,
variant: &syn::Variant,
) -> syn::Result<VariantParts> {
let &VariantCtx {
vname,
disc,
kind,
data,
view,
payload_const,
..
} = ctx;
let mut parts = VariantParts::default();
if kind != Kind::Pod {
return Err(Error::new_spanned(
variant,
"[BSTACK0205] an ownership annotation is only allowed on a single-field tuple \
variant, e.g. `#[bstack_owned] V(T)`",
));
}
let named = matches!(&variant.fields, syn::Fields::Named(_));
let mut binds = Vec::new();
let mut tys: Vec<Type> = Vec::new();
let mut fnames = Vec::new();
for (j, f) in variant.fields.iter().enumerate() {
parts.pod_types.push(f.ty.clone());
tys.push(f.ty.clone());
binds.push(format_ident!("__f{}", j));
if let Some(id) = &f.ident {
fnames.push(id.clone());
}
}
let mut offsets = Vec::new();
let mut acc = quote!(0usize);
for ty in &tys {
offsets.push(acc.clone());
acc = quote!(#acc + ::core::mem::size_of::<#ty>());
}
let payload_size = if tys.is_empty() { quote!(0usize) } else { acc };
let writes = binds.iter().zip(&offsets).zip(&tys).map(|((b, off), ty)| {
quote! {
__pl[(#off)..(#off) + ::core::mem::size_of::<#ty>()]
.copy_from_slice(::bstack_raii::bytemuck::bytes_of(&#b));
}
});
let reads: Vec<TokenStream> = offsets
.iter()
.zip(&tys)
.map(|(off, ty)| {
quote! {
::bstack_raii::bytemuck::pod_read_unaligned::<#ty>(
&__pl[(#off)..(#off) + ::core::mem::size_of::<#ty>()],
)
}
})
.collect();
let (decl, pat, cons) = if tys.is_empty() {
(quote!(#vname,), quote!(#vname), quote!(#vname))
} else if named {
(
quote!(#vname { #(#fnames: #tys),* },),
quote!(#vname { #(#fnames: #binds),* }),
quote!(#vname { #(#fnames: #reads),* }),
)
} else {
(
quote!(#vname(#(#tys),*),),
quote!(#vname(#(#binds),*)),
quote!(#vname(#(#reads),*)),
)
};
if !tys.is_empty() {
parts.needs_payload = true;
}
parts.data_variants.push(decl.clone());
parts.view_variants.push(decl);
parts.payload_sizes.push(payload_size);
parts.new_arms.push(quote! {
#data::#pat => {
let mut __pl = [0u8; #payload_const];
#(#writes)*
(#disc, __pl)
}
});
parts.read_arms.push(quote!(#disc => #view::#cons,));
parts.move_arms.push(quote!(#disc => #data::#cons,));
Ok(parts)
}
pub(crate) fn single_block_variant(ctx: &VariantCtx, ty: &Type) -> syn::Result<VariantParts> {
let &VariantCtx {
vname,
disc,
kind,
data,
view,
on_disk,
payload_const,
} = ctx;
let mut parts = VariantParts::default();
let child_from_off = |ty: &Type| {
quote! {
unsafe { <#ty as ::bstack_raii::BStackBlock>::from_range(::bstack_raii::BStackRange::new(
::bstack_raii::get_u64(&__pl),
::core::mem::size_of::<<#ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64,
)) }
}
};
let child_ref = |ty: &Type| {
quote! {
::bstack_raii::BStackRef::<#ty>::from_range(::bstack_raii::BStackRange::new(
::bstack_raii::get_u64(&__pl),
::core::mem::size_of::<<#ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64,
))
}
};
match kind {
Kind::Pod => unreachable!("guarded out above"),
Kind::Owned => {
parts.payload_sizes.push(quote!(8usize));
let child = child_from_off(ty);
parts
.data_variants
.push(quote!(#vname(::bstack_raii::BStackOwned<#ty>),));
parts.view_variants.push(quote!(#vname(#ty),));
parts.new_arms.push(quote! {
#data::#vname(__v) => {
let __h = __v.into_inner();
let __off = ::bstack_raii::BStackBlock::range(&__h).start();
let mut __pl = [0u8; #payload_const];
__pl[..8].copy_from_slice(&__off.to_le_bytes());
(#disc, __pl)
}
});
parts
.read_arms
.push(quote!(#disc => #view::#vname(#child),));
parts.move_arms.push(quote! {
#disc => #data::#vname(unsafe {
::bstack_raii::BStackOwned::from_raw(#child)
}),
});
parts.drop_arms.push(quote! {
#disc => {
let __child = unsafe {
::bstack_raii::BStackRef::<#ty>::from_range(
::bstack_raii::BStackRange::new(
::bstack_raii::get_u64(&__pl),
::core::mem::size_of::<
<#ty as ::bstack_raii::BStackBlock>::OnDisk
>() as u64,
),
)
};
unsafe { ::bstack_raii::OwnedRef::new(__child) }.bstack_drop(allocator)?;
}
});
parts.clone_arms.push(quote! {
#disc => {
let __off = ::bstack_raii::get_u64(&__pl);
let __child = unsafe { <#ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
__off,
::core::mem::size_of::<
<#ty as ::bstack_raii::BStackBlock>::OnDisk
>() as u64,
),
) };
let __new = __child.__bstack_clone_into(allocator, __plan)?;
__pl[..8].copy_from_slice(&__new.start().to_le_bytes());
}
});
}
Kind::Ref => {
parts.payload_sizes.push(quote!(8usize));
let child = child_from_off(ty);
let cref = child_ref(ty);
parts
.data_variants
.push(quote!(#vname(::bstack_raii::BStackRef<#ty>),));
parts.view_variants.push(quote!(#vname(#ty),));
parts.new_arms.push(quote! {
#data::#vname(__v) => {
let mut __pl = [0u8; #payload_const];
__pl[..8].copy_from_slice(&__v.into_range().start().to_le_bytes());
(#disc, __pl)
}
});
parts
.read_arms
.push(quote!(#disc => #view::#vname(#child),));
parts
.move_arms
.push(quote!(#disc => #data::#vname(unsafe { #cref }),));
}
Kind::Strong => {
parts.has_shared = true;
parts.payload_sizes.push(quote!(8usize));
let child = child_from_off(ty);
let cref = child_ref(ty);
parts
.data_variants
.push(quote!(#vname(::bstack_raii::BStackRc<'__e, #ty, __A>),));
parts.view_variants.push(quote!(#vname(#ty),));
parts.new_arms.push(quote! {
#data::#vname(__v) => {
let (__data, _ctrl) = __v.into_raw();
let mut __pl = [0u8; #payload_const];
__pl[..8].copy_from_slice(&__data.into_range().start().to_le_bytes());
(#disc, __pl)
}
});
parts
.read_arms
.push(quote!(#disc => #view::#vname(#child),));
parts.move_arms.push(quote! {
#disc => {
let __data = unsafe { #cref };
let (__d, __c) =
<#ty as ::bstack_raii::BStackShared>::strong_parts(__data, __alloc)?;
#data::#vname(unsafe {
::bstack_raii::BStackRc::from_raw(__d, __c, __alloc)
})
}
});
parts.drop_arms.push(quote! {
#disc => {
let __data = unsafe { #cref };
<#ty as ::bstack_raii::BStackShared>::drop_strong_ref(
__data, allocator,
)?;
}
});
parts.raw_arms.push(quote! {
#disc => ::std::vec![::bstack_raii::BStackRange::new(
::bstack_raii::get_u64(&__pl),
::core::mem::size_of::<<#ty as ::bstack_raii::BStackBlock>::OnDisk>() as u64,
)],
});
parts.clone_arms.push(quote! {
#disc => {
let __data = unsafe { #cref };
__plan.bump_strong(__data, allocator)?;
}
});
}
Kind::Weak => {
parts.has_shared = true;
parts.has_weak = true;
parts.payload_sizes.push(quote!(8usize));
let ctrl_ref = quote! {
unsafe {
::bstack_raii::BStackRef::<
<#ty as ::bstack_raii::BStackWeakable>::Control
>::from_range(::bstack_raii::BStackRange::new(
::bstack_raii::get_u64(&__pl),
::core::mem::size_of::<
<#ty as ::bstack_raii::BStackWeakable>::Control
>() as u64,
))
}
};
parts
.data_variants
.push(quote!(#vname(::bstack_raii::BStackWeak<'__e, #ty, __A>),));
parts.view_variants.push(quote! {
#vname(::core::option::Option<
::bstack_raii::BStackRc<'__e, #ty, __A>
>),
});
parts.new_arms.push(quote! {
#data::#vname(__v) => {
let __ctrl = __v.into_raw();
let mut __pl = [0u8; #payload_const];
__pl[..8].copy_from_slice(&__ctrl.into_range().start().to_le_bytes());
(#disc, __pl)
}
});
parts.read_arms.push(quote! {
#disc => {
let __w = unsafe {
::bstack_raii::BStackWeak::<#ty, __A>::from_raw(#ctrl_ref, allocator)
};
let __up = __w.upgrade()?;
let _ = __w.into_raw();
#view::#vname(__up)
}
});
parts.move_arms.push(quote! {
#disc => #data::#vname(unsafe {
::bstack_raii::BStackWeak::from_raw(#ctrl_ref, __alloc)
}),
});
parts.drop_arms.push(quote! {
#disc => {
unsafe { ::bstack_raii::WeakRef::<#ty>::new(#ctrl_ref) }.bstack_drop(allocator)?;
}
});
parts.clone_arms.push(quote! {
#disc => {
let __ctrl_off = ::bstack_raii::get_u64(&__pl);
__plan.bump_weak(__ctrl_off)?;
}
});
}
Kind::Embed => {
parts.embed_types.push(quote!(#ty));
let co = quote!(<#ty as ::bstack_raii::BStackBlock>::OnDisk);
parts
.payload_sizes
.push(quote!(::core::mem::size_of::<#co>()));
parts
.data_variants
.push(quote!(#vname(::bstack_raii::BStackOwned<#ty>),));
parts.view_variants.push(quote!(#vname(#ty),));
parts.has_embed = true;
parts.new_arms.push(quote! {
#data::#vname(__v) => {
let __h = __v.into_inner();
let __cr = ::bstack_raii::BStackBlock::range(&__h);
__embed_copy.push((
__cr,
::core::mem::size_of::<#co>() as u64,
0u64,
));
(#disc, [0u8; #payload_const])
}
});
parts.read_arms.push(quote! {
#disc => #view::#vname(
unsafe { <#ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
self.0.start()
+ ::core::mem::offset_of!(#on_disk, __bstack_payload)
as u64,
::core::mem::size_of::<#co>() as u64,
),
) }
),
});
parts.move_arms.push(quote! {
#disc => {
let mut __slice =
__alloc.alloc(::core::mem::size_of::<#co>() as u64)?;
let __r = __slice.as_range();
if let ::std::result::Result::Err(__e) = __slice
.write_range(0, &__pl[..::core::mem::size_of::<#co>()])
{
let _ = __alloc.dealloc(__slice);
return ::std::result::Result::Err(__e);
}
#data::#vname(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#ty as ::bstack_raii::BStackBlock>::from_range(__r) },
)
})
}
});
parts.drop_arms.push(quote! {
#disc => {
let __embed = ::bstack_raii::BStackRange::new(
__range.start()
+ ::core::mem::offset_of!(#on_disk, __bstack_payload) as u64,
::core::mem::size_of::<#co>() as u64,
);
<#ty>::__bstack_drop_children(allocator, __embed)?;
}
});
parts.clone_arms.push(quote! {
#disc => {
let __child = unsafe { <#ty as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
self.0.start()
+ ::core::mem::offset_of!(#on_disk, __bstack_payload)
as u64,
::core::mem::size_of::<#co>() as u64,
),
) };
let __fixed =
__child.__bstack_clone_children_inplace(allocator, __plan)?;
__pl[..::core::mem::size_of::<#co>()]
.copy_from_slice(::bstack_raii::bytemuck::bytes_of(&__fixed));
}
});
}
}
Ok(parts)
}
pub(crate) fn foreign_variant(ctx: &VariantCtx, ty: &Type) -> syn::Result<Option<VariantParts>> {
let &VariantCtx {
vname,
disc,
kind,
data,
view,
payload_const,
..
} = ctx;
let Some(ftarget) = foreign_inner(ty) else {
return Ok(None);
};
let mut parts = VariantParts::default();
match kind {
Kind::Owned | Kind::Strong | Kind::Weak | Kind::Ref => {}
Kind::Pod => {
return Err(Error::new_spanned(
ty,
"[BSTACK0302] a `Foreign` enum variant needs an ownership annotation \
(`#[bstack_owned/strong/weak/ref]`) naming the target's kind",
));
}
Kind::Embed => {
return Err(Error::new_spanned(
ty,
"[BSTACK0301] `Foreign` is a pointer and cannot be `#[embed]`ed",
));
}
}
reject_bad_foreign_target(ftarget, ty, "a `Foreign` enum variant")?;
parts.has_foreign = true;
parts.payload_sizes.push(quote!(16usize));
let fty = quote!(::bstack_raii::Foreign<'__e, #ftarget>);
let read_fp = quote!(::bstack_raii::bytemuck::pod_read_unaligned::<
::bstack_raii::WidePtr,
>(&__pl[..16]));
let read_resolved =
quote!(::bstack_raii::registry::resolve_self_repr(#read_fp, allocator.stack())?);
let move_resolved =
quote!(::bstack_raii::registry::resolve_self_repr(#read_fp, __alloc.stack())?);
parts.data_variants.push(quote!(#vname(#fty),));
parts.view_variants.push(quote!(#vname(#fty),));
parts.new_arms.push(quote! {
#data::#vname(__f) => {
let mut __pl = [0u8; #payload_const];
__pl[..16].copy_from_slice(::bstack_raii::bytemuck::bytes_of(
&::bstack_raii::registry::home_relative_repr(__f.repr(), allocator.stack())));
(#disc, __pl)
}
});
parts.read_arms.push(quote!(#disc => #view::#vname(
unsafe { ::bstack_raii::Foreign::from_repr(#read_resolved) }),));
parts.move_arms.push(quote!(#disc => #data::#vname(
unsafe { ::bstack_raii::Foreign::from_repr(#move_resolved) }),));
if !matches!(kind, Kind::Ref) {
let elem_drop = foreign_elem_drop(kind, ftarget);
parts.drop_arms.push(quote! {
#disc => {
let __fp: ::bstack_raii::WidePtr = #read_fp;
#elem_drop
}
});
let elem_clone = foreign_elem_clone(kind, ftarget);
parts.clone_arms.push(quote! {
#disc => {
let __fp: ::bstack_raii::WidePtr = #read_fp;
#elem_clone
__pl[..16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__newfp));
}
});
}
Ok(Some(parts))
}
pub(crate) fn foreign_tuple_variant(
ctx: &VariantCtx,
ty: &Type,
) -> syn::Result<Option<VariantParts>> {
let &VariantCtx {
vname,
disc,
kind,
data,
view,
payload_const,
..
} = ctx;
let Type::Tuple(tup) = ty else {
return Ok(None);
};
if !tup
.elems
.iter()
.any(|e| foreign_inner(option_inner(e).unwrap_or(e)).is_some())
{
return Ok(None);
}
let mut parts = VariantParts::default();
if kind == Kind::Embed {
return Err(Error::new_spanned(
ty,
"[BSTACK0502] cannot #[embed] a tuple",
));
}
let nelem = tup.elems.len();
let mut is_foreign = Vec::with_capacity(nelem);
let mut ftargets: Vec<Option<&Type>> = Vec::with_capacity(nelem);
let mut nulls = Vec::with_capacity(nelem);
for e in &tup.elems {
let inner = option_inner(e).unwrap_or(e);
if let Some(ft) = foreign_inner(inner) {
reject_bad_foreign_target(ft, ty, "a `Foreign` tuple element")?;
is_foreign.push(true);
ftargets.push(Some(ft));
nulls.push(option_inner(e).is_some());
} else {
is_foreign.push(false);
ftargets.push(None);
nulls.push(false);
parts.pod_types.push(e.clone());
}
}
let mut offsets = Vec::with_capacity(nelem);
let mut acc = quote!(0usize);
let mut sizes = Vec::with_capacity(nelem);
for (&frn, e) in is_foreign.iter().zip(&tup.elems) {
offsets.push(acc.clone());
let sz = if frn {
quote!(16usize)
} else {
quote!(::core::mem::size_of::<#e>())
};
sizes.push(sz.clone());
acc = quote!(#acc + #sz);
}
parts.payload_sizes.push(acc);
parts.has_foreign = true;
let pub_elems: Vec<TokenStream> = (0..nelem)
.map(|i| {
if is_foreign[i] {
let ft = ftargets[i].unwrap();
if nulls[i] {
quote!(::core::option::Option<::bstack_raii::Foreign<'__e, #ft>>)
} else {
quote!(::bstack_raii::Foreign<'__e, #ft>)
}
} else {
let e = &tup.elems[i];
quote!(#e)
}
})
.collect();
let pub_tuple_ty = quote!(( #(#pub_elems,)* ));
parts.data_variants.push(quote!(#vname(#pub_tuple_ty),));
parts.view_variants.push(quote!(#vname(#pub_tuple_ty),));
let binds: Vec<Ident> = (0..nelem).map(|i| format_ident!("__f{}", i)).collect();
let writes: Vec<TokenStream> = (0..nelem)
.map(|i| {
let b = &binds[i];
let off = &offsets[i];
let sz = &sizes[i];
if is_foreign[i] {
let to_fp = if nulls[i] {
quote!(match #b {
::core::option::Option::Some(__x) =>
::bstack_raii::registry::home_relative_repr(
__x.repr(), allocator.stack()),
::core::option::Option::None =>
::bstack_raii::WidePtr::NULL,
})
} else {
quote!(::bstack_raii::registry::home_relative_repr(
#b.repr(), allocator.stack()))
};
quote!(__pl[(#off)..(#off) + 16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&(#to_fp)));)
} else {
quote!(__pl[(#off)..(#off) + #sz].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&#b));)
}
})
.collect();
parts.new_arms.push(quote! {
#data::#vname(( #(#binds,)* )) => {
let mut __pl = [0u8; #payload_const];
#(#writes)*
(#disc, __pl)
}
});
let make_reads = |stack: &TokenStream| -> Vec<TokenStream> {
(0..nelem)
.map(|i| {
let off = &offsets[i];
let sz = &sizes[i];
if is_foreign[i] {
let ft = ftargets[i].unwrap();
let fp = quote!(::bstack_raii::bytemuck::pod_read_unaligned::<
::bstack_raii::WidePtr,
>(&__pl[(#off)..(#off) + 16]));
if nulls[i] {
quote!({
let __p = #fp;
if __p.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr =
::bstack_raii::registry::resolve_self_repr(__p, #stack)?;
::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ft>::from_repr(__repr) })
}
})
} else {
quote!({
let __repr =
::bstack_raii::registry::resolve_self_repr(#fp, #stack)?;
unsafe { ::bstack_raii::Foreign::<#ft>::from_repr(__repr) }
})
}
} else {
let e = &tup.elems[i];
quote!(::bstack_raii::bytemuck::pod_read_unaligned::<#e>(
&__pl[(#off)..(#off) + #sz]))
}
})
.collect()
};
let read_reads = make_reads("e!(allocator.stack()));
let move_reads = make_reads("e!(__alloc.stack()));
parts
.read_arms
.push(quote!(#disc => #view::#vname(( #(#read_reads,)* )),));
parts
.move_arms
.push(quote!(#disc => #data::#vname(( #(#move_reads,)* )),));
if !matches!(kind, Kind::Ref) {
let mut drops = Vec::new();
let mut clones = Vec::new();
for i in 0..nelem {
if !is_foreign[i] {
continue;
}
let off = &offsets[i];
let ft = ftargets[i].unwrap();
let read_fp = quote!(::bstack_raii::bytemuck::pod_read_unaligned::<
::bstack_raii::WidePtr,
>(&__pl[(#off)..(#off) + 16]));
let ed = foreign_elem_drop(kind, ft);
drops.push(quote! { { let __fp: ::bstack_raii::WidePtr = #read_fp; #ed } });
let ec = foreign_elem_clone(kind, ft);
clones.push(quote! {
{
let __fp: ::bstack_raii::WidePtr = #read_fp;
#ec
__pl[(#off)..(#off) + 16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__newfp));
}
});
}
parts.drop_arms.push(quote!(#disc => { #(#drops)* }));
parts.clone_arms.push(quote!(#disc => { #(#clones)* }));
}
Ok(Some(parts))
}
pub(crate) fn array_variant(ctx: &VariantCtx, ty: &Type) -> syn::Result<Option<VariantParts>> {
let &VariantCtx {
vname,
disc,
kind,
data,
view,
on_disk,
payload_const,
} = ctx;
let Type::Array(_) = ty else {
return Ok(None);
};
let mut parts = VariantParts::default();
let (dims, elem, elem_nullable) = array_shape(ty)?;
let total = dims_prod(&dims);
if let Some(ftarget) = foreign_inner(elem) {
match kind {
Kind::Owned | Kind::Strong | Kind::Weak | Kind::Ref => {}
Kind::Pod => {
return Err(Error::new_spanned(
ty,
"[BSTACK0302] a `[Foreign<T>; N]` enum variant needs an ownership \
annotation (`#[bstack_owned/strong/weak/ref]`)",
));
}
Kind::Embed => {
return Err(Error::new_spanned(
ty,
"[BSTACK0301] `Foreign` is a pointer and cannot be `#[embed]`ed",
));
}
}
reject_bad_foreign_target(ftarget, ty, "a `Foreign` array variant")?;
parts.has_foreign = true;
parts.payload_sizes.push(quote!((#total) * 16));
let fty = if elem_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<'__e, #ftarget>>)
} else {
quote!(::bstack_raii::Foreign<'__e, #ftarget>)
};
let fty_mv = if elem_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<'__mv, #ftarget>>)
} else {
quote!(::bstack_raii::Foreign<'__mv, #ftarget>)
};
let nested = nested_ty(&dims, &fty);
parts.data_variants.push(quote!(#vname(#nested),));
parts.view_variants.push(quote!(#vname(#nested),));
let leaf_write = |k: &Ident, leaf: &Ident| {
let to_fp = if elem_nullable {
quote!(match #leaf {
::core::option::Option::Some(__f) =>
::bstack_raii::registry::home_relative_repr(
__f.repr(), allocator.stack()),
::core::option::Option::None =>
::bstack_raii::WidePtr::NULL,
})
} else {
quote!(::bstack_raii::registry::home_relative_repr(
#leaf.repr(), allocator.stack()))
};
quote!(__pl[(#k) * 16..(#k) * 16 + 16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&(#to_fp)));)
};
let flatten = nested_consume(&dims, "e!(__list), &leaf_write);
parts.new_arms.push(quote! {
#data::#vname(__list) => {
let mut __pl = [0u8; #payload_const];
#flatten
(#disc, __pl)
}
});
let leaf_read = |stk: &TokenStream, k: &Ident| {
let fp = quote!(::bstack_raii::bytemuck::pod_read_unaligned::<
::bstack_raii::WidePtr,
>(&__pl[(#k) * 16..(#k) * 16 + 16]));
if elem_nullable {
quote!({
let __p = #fp;
if __p.offset().get() == 0 {
::core::option::Option::None
} else {
let __repr = ::bstack_raii::registry::resolve_self_repr(__p, #stk)?;
::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) })
}
})
} else {
quote!({
let __repr = ::bstack_raii::registry::resolve_self_repr(#fp, #stk)?;
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) }
})
}
};
let build_e = nested_build(&dims, &fty, &|k| leaf_read("e!(allocator.stack()), k));
let build_mv = nested_build(&dims, &fty_mv, &|k| leaf_read("e!(__alloc.stack()), k));
parts
.read_arms
.push(quote!(#disc => #view::#vname(#build_e),));
parts
.move_arms
.push(quote!(#disc => #data::#vname(#build_mv),));
if !matches!(kind, Kind::Ref) {
let elem_drop = foreign_elem_drop(kind, ftarget);
parts.drop_arms.push(quote! {
#disc => {
for __k in 0usize..(#total) {
let __fp = ::bstack_raii::bytemuck::pod_read_unaligned::<
::bstack_raii::WidePtr,
>(&__pl[__k * 16..__k * 16 + 16]);
#elem_drop
}
}
});
let elem_clone = foreign_elem_clone(kind, ftarget);
parts.clone_arms.push(quote! {
#disc => {
for __k in 0usize..(#total) {
let __fp = ::bstack_raii::bytemuck::pod_read_unaligned::<
::bstack_raii::WidePtr,
>(&__pl[__k * 16..__k * 16 + 16]);
#elem_clone
__pl[__k * 16..__k * 16 + 16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__newfp));
}
}
});
}
return Ok(Some(parts));
}
let pl_off = |k: &Ident| quote!(::bstack_raii::get_u64(&__pl[(#k) * 8..]));
let pl_put = |k: &Ident, off: TokenStream| {
quote!(__pl[(#k) * 8..(#k) * 8 + 8]
.copy_from_slice(&(#off).to_le_bytes());)
};
if kind == Kind::Embed {
if elem_nullable {
return Err(Error::new_spanned(
ty,
"[BSTACK0503] #[embed] does not support `Option`",
));
}
parts.has_embed = true;
let child = elem;
parts.embed_types.push(quote!(#child));
let co = quote!(<#child as ::bstack_raii::BStackBlock>::OnDisk);
parts
.payload_sizes
.push(quote!((#total) * ::core::mem::size_of::<#co>()));
let data_leaf = quote!(::bstack_raii::BStackOwned<#child>);
let data_ty_nested = nested_ty(&dims, &data_leaf);
parts.data_variants.push(quote!(#vname(#data_ty_nested),));
let view_ty_nested = nested_ty(&dims, "e!(#child));
parts.view_variants.push(quote!(#vname(#view_ty_nested),));
let cap_write = |k: &Ident, leaf: &Ident| {
quote! {
let __h = #leaf.into_inner();
let __cr = ::bstack_raii::BStackBlock::range(&__h);
__embed_copy.push((
__cr,
::core::mem::size_of::<#co>() as u64,
(#k as u64) * ::core::mem::size_of::<#co>() as u64,
));
}
};
let consume = nested_consume(&dims, "e!(__arr), &cap_write);
parts.new_arms.push(quote! {
#data::#vname(__arr) => {
#consume
(#disc, [0u8; #payload_const])
}
});
let read_leaf = |k: &Ident| {
quote!(unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
__base + (#k as u64) * __step, __step)) })
};
let read_body = nested_build(&dims, "e!(#child), &read_leaf);
parts.read_arms.push(quote! {
#disc => {
let __base = self.0.start()
+ ::core::mem::offset_of!(#on_disk, __bstack_payload) as u64;
let __step = ::core::mem::size_of::<#co>() as u64;
#view::#vname(#read_body)
}
});
let mv_read = |k: &Ident| {
quote! {{
let __start = (#k) * ::core::mem::size_of::<#co>();
let mut __slice =
__alloc.alloc(::core::mem::size_of::<#co>() as u64)?;
let __r = __slice.as_range();
if let ::std::result::Result::Err(__e) = __slice.write_range(
0, &__pl[__start..__start + ::core::mem::size_of::<#co>()])
{
let _ = __alloc.dealloc(__slice);
return ::std::result::Result::Err(__e);
}
unsafe { ::bstack_raii::BStackOwned::from_raw(
unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(__r) }) }
}}
};
let mv_body = nested_build(&dims, &data_leaf, &mv_read);
parts
.move_arms
.push(quote!(#disc => #data::#vname(#mv_body),));
parts.drop_arms.push(quote! {
#disc => {
let __base = __range.start()
+ ::core::mem::offset_of!(#on_disk, __bstack_payload) as u64;
let __step = ::core::mem::size_of::<#co>() as u64;
for __k in 0usize..(#total) {
let __embed = ::bstack_raii::BStackRange::new(
__base + (__k as u64) * __step, __step);
<#child>::__bstack_drop_children(allocator, __embed)?;
}
}
});
parts.clone_arms.push(quote! {
#disc => {
let __base = self.0.start()
+ ::core::mem::offset_of!(#on_disk, __bstack_payload) as u64;
let __step = ::core::mem::size_of::<#co>() as u64;
for __k in 0usize..(#total) {
let __child = unsafe { <#child as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(
__base + (__k as u64) * __step, __step)) };
let __fixed =
__child.__bstack_clone_children_inplace(allocator, __plan)?;
let __start = (__k) * ::core::mem::size_of::<#co>();
__pl[__start..__start + ::core::mem::size_of::<#co>()]
.copy_from_slice(::bstack_raii::bytemuck::bytes_of(&__fixed));
}
}
});
return Ok(Some(parts));
}
let elem_size = quote!(::core::mem::size_of::<
<#elem as ::bstack_raii::BStackBlock>::OnDisk>() as u64);
parts.payload_sizes.push(quote!((#total) * 8));
if kind == Kind::Weak {
parts.has_shared = true;
parts.has_weak = true;
let ctrl_ty = quote!(<#elem as ::bstack_raii::BStackWeakable>::Control);
let ctrl_size = quote!(::core::mem::size_of::<#ctrl_ty>() as u64);
let data_leaf = quote!(::bstack_raii::BStackWeak<'__e, #elem, __A>);
let data_ty_nested = nested_ty(&dims, &data_leaf);
parts.data_variants.push(quote!(#vname(#data_ty_nested),));
let view_leaf = quote!(::core::option::Option<::bstack_raii::BStackRc<'__e, #elem, __A>>);
let view_ty_nested = nested_ty(&dims, &view_leaf);
parts.view_variants.push(quote!(#vname(#view_ty_nested),));
let cap_write =
|k: &Ident, leaf: &Ident| pl_put(k, quote!(#leaf.into_raw().into_range().start()));
let consume = nested_consume(&dims, "e!(__arr), &cap_write);
parts.new_arms.push(quote! {
#data::#vname(__arr) => {
let mut __pl = [0u8; #payload_const];
#consume
(#disc, __pl)
}
});
let view_leaf_e = view_leaf.clone();
let read_leaf = |k: &Ident| {
let off = pl_off(k);
quote! {{
let __off = #off;
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #ctrl_size)) };
let __wk = unsafe {
::bstack_raii::BStackWeak::<#elem, __A>::from_raw(__ctrl, allocator) };
let __up = __wk.upgrade()?;
let _ = __wk.into_raw();
__up
}}
};
let read_body = nested_build(&dims, &view_leaf_e, &read_leaf);
parts
.read_arms
.push(quote!(#disc => #view::#vname(#read_body),));
let mv_leaf = quote!(::bstack_raii::BStackWeak<'__mv, #elem, __A>);
let mv_read = |k: &Ident| {
let off = pl_off(k);
quote! {{
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(#off, #ctrl_size)) };
unsafe { ::bstack_raii::BStackWeak::from_raw(__ctrl, __alloc) }
}}
};
let mv_body = nested_build(&dims, &mv_leaf, &mv_read);
parts
.move_arms
.push(quote!(#disc => #data::#vname(#mv_body),));
parts.drop_arms.push(quote! {
#disc => {
for __k in 0usize..(#total) {
let __off = ::bstack_raii::get_u64(&__pl[__k * 8..]);
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__off, #ctrl_size)) };
unsafe { ::bstack_raii::WeakRef::<#elem>::new(__ctrl) }.bstack_drop(allocator)?;
}
}
});
parts.clone_arms.push(quote! {
#disc => {
for __k in 0usize..(#total) {
let __off = ::bstack_raii::get_u64(&__pl[__k * 8..]);
__plan.bump_weak(__off)?;
}
}
});
return Ok(Some(parts));
}
if kind == Kind::Strong {
parts.has_shared = true;
}
let view_leaf = if elem_nullable {
quote!(::core::option::Option<#elem>)
} else {
quote!(#elem)
};
let view_ty_nested = nested_ty(&dims, &view_leaf);
parts.view_variants.push(quote!(#vname(#view_ty_nested),));
let data_leaf = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__e, #elem, __A>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem>),
_ => unreachable!(),
};
let data_leaf_full = if elem_nullable {
quote!(::core::option::Option<#data_leaf>)
} else {
data_leaf.clone()
};
let data_ty_nested = nested_ty(&dims, &data_leaf_full);
parts.data_variants.push(quote!(#vname(#data_ty_nested),));
let off_of = |h: &Ident| match kind {
Kind::Owned => quote!({
let __h = #h.into_inner();
::bstack_raii::BStackBlock::range(&__h).start()
}),
Kind::Strong => quote!({
let (__d, _c) = #h.into_raw();
__d.into_range().start()
}),
Kind::Ref => quote!(#h.into_range().start()),
_ => unreachable!(),
};
let cap_write = |k: &Ident, leaf: &Ident| {
if elem_nullable {
let hh = format_ident!("__handle");
let off = off_of(&hh);
let put = pl_put(k, quote!(__off));
quote! {{
let __off: u64 = match #leaf {
::core::option::Option::Some(#hh) => #off,
::core::option::Option::None => 0u64,
};
#put
}}
} else {
pl_put(k, off_of(leaf))
}
};
let consume = nested_consume(&dims, "e!(__arr), &cap_write);
parts.new_arms.push(quote! {
#data::#vname(__arr) => {
let mut __pl = [0u8; #payload_const];
#consume
(#disc, __pl)
}
});
let read_leaf = |k: &Ident| {
let off = pl_off(k);
let build = quote!(unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__off, #elem_size)) });
if elem_nullable {
quote! {{
let __off = #off;
if __off == 0 { ::core::option::Option::None }
else { ::core::option::Option::Some(#build) }
}}
} else {
quote!({ let __off = #off; #build })
}
};
let read_body = nested_build(&dims, &view_leaf, &read_leaf);
parts
.read_arms
.push(quote!(#disc => #view::#vname(#read_body),));
let mv_leaf_base = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__mv, #elem, __A>),
_ => unreachable!(),
};
let mv_leaf_ty = if elem_nullable {
quote!(::core::option::Option<#mv_leaf_base>)
} else {
mv_leaf_base.clone()
};
let build_one = match kind {
Kind::Owned => quote!(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__off, #elem_size)) })
}),
Kind::Ref => quote!(unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #elem_size))
}),
Kind::Strong => quote!({
let __data = unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #elem_size)) };
let (__d, __c) =
<#elem as ::bstack_raii::BStackShared>::strong_parts(__data, __alloc)?;
unsafe { ::bstack_raii::BStackRc::from_raw(__d, __c, __alloc) }
}),
_ => unreachable!(),
};
let mv_read = |k: &Ident| {
let off = pl_off(k);
if elem_nullable {
quote! {{
let __off = #off;
if __off == 0 { ::core::option::Option::None }
else { ::core::option::Option::Some(#build_one) }
}}
} else {
quote!({ let __off = #off; #build_one })
}
};
let mv_body = nested_build(&dims, &mv_leaf_ty, &mv_read);
parts
.move_arms
.push(quote!(#disc => #data::#vname(#mv_body),));
if kind != Kind::Ref {
let per = match kind {
Kind::Owned => quote! {
unsafe { ::bstack_raii::OwnedRef::new(__child) }.bstack_drop(allocator)?;
},
Kind::Strong => quote! {
<#elem as ::bstack_raii::BStackShared>::drop_strong_ref(
__child, allocator)?;
},
_ => unreachable!(),
};
parts.drop_arms.push(quote! {
#disc => {
for __k in 0usize..(#total) {
let __off = ::bstack_raii::get_u64(&__pl[__k * 8..]);
if __off != 0 {
let __child = unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #elem_size)) };
#per
}
}
}
});
}
match kind {
Kind::Owned => parts.clone_arms.push(quote! {
#disc => {
for __k in 0usize..(#total) {
let __off = ::bstack_raii::get_u64(&__pl[__k * 8..]);
if __off != 0 {
let __child =
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__off, #elem_size)) };
let __new = __child.__bstack_clone_into(allocator, __plan)?;
__pl[__k * 8..__k * 8 + 8]
.copy_from_slice(&__new.start().to_le_bytes());
}
}
}
}),
Kind::Strong => parts.clone_arms.push(quote! {
#disc => {
for __k in 0usize..(#total) {
let __off = ::bstack_raii::get_u64(&__pl[__k * 8..]);
if __off != 0 {
let __data = unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__off, #elem_size)) };
__plan.bump_strong(__data, allocator)?;
}
}
}
}),
_ => {}
}
Ok(Some(parts))
}
pub(crate) fn vec_variant(
ctx: &VariantCtx,
ty: &Type,
payload_loc: &TokenStream,
) -> syn::Result<Option<VariantParts>> {
let &VariantCtx {
vname,
disc,
kind,
data,
view,
payload_const,
..
} = ctx;
if vec_info(ty).is_none() {
return Ok(None);
}
let mut parts = VariantParts::default();
check_container_nesting(ty)?;
if kind == Kind::Embed {
return Err(Error::new_spanned(
ty,
"[BSTACK0501] cannot #[embed] a `Vec`; embed a `#[bstack_block]` type",
));
}
parts.needs_payload = true;
parts
.payload_sizes
.push(quote!(::core::mem::size_of::<::bstack_raii::VecDesc>()));
let read_desc = quote!(::bstack_raii::bytemuck::pod_read_unaligned::<
::bstack_raii::VecDesc,
>(&__pl[..16]));
if let Some(velem) = vec_inner(ty)
&& let Some(ftarget) = foreign_inner(option_inner(velem).unwrap_or(velem))
{
match kind {
Kind::Owned | Kind::Strong | Kind::Weak | Kind::Ref => {}
Kind::Pod => {
return Err(Error::new_spanned(
ty,
"[BSTACK0302] a `Vec<Foreign<T>>` enum variant needs an ownership \
annotation (`#[bstack_owned/strong/weak/ref]`)",
));
}
Kind::Embed => {
return Err(Error::new_spanned(
ty,
"[BSTACK0301] `Foreign` is a pointer and cannot be `#[embed]`ed",
));
}
}
reject_bad_foreign_target(ftarget, ty, "a `Foreign` vec variant")?;
parts.has_foreign = true;
let elem_nullable = option_inner(velem).is_some();
let store = quote!(::bstack_raii::BStackVec::<::bstack_raii::WidePtr, __A>);
let fty = if elem_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<'__e, #ftarget>>)
} else {
quote!(::bstack_raii::Foreign<'__e, #ftarget>)
};
let fty_mv = if elem_nullable {
quote!(::core::option::Option<::bstack_raii::Foreign<'__mv, #ftarget>>)
} else {
quote!(::bstack_raii::Foreign<'__mv, #ftarget>)
};
let make_from_ptr = |ret: &TokenStream, stk: &TokenStream| {
if elem_nullable {
quote!(|__p: ::bstack_raii::WidePtr| -> ::std::io::Result<#ret> {
if __p.offset().get() == 0 {
::std::result::Result::Ok(::core::option::Option::None)
} else {
let __repr = ::bstack_raii::registry::resolve_self_repr(__p, #stk)?;
::std::result::Result::Ok(::core::option::Option::Some(
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) }))
}
})
} else {
quote!(|__p: ::bstack_raii::WidePtr| -> ::std::io::Result<#ret> {
let __repr = ::bstack_raii::registry::resolve_self_repr(__p, #stk)?;
::std::result::Result::Ok(
unsafe { ::bstack_raii::Foreign::<#ftarget>::from_repr(__repr) })
})
}
};
let from_ptr_e = make_from_ptr(&fty, "e!(allocator.stack()));
let from_ptr_mv = make_from_ptr(&fty_mv, "e!(__alloc.stack()));
let to_ptr = if elem_nullable {
quote!(|__f: #fty| match __f {
::core::option::Option::Some(__ff) =>
::bstack_raii::registry::home_relative_repr(__ff.repr(), allocator.stack()),
::core::option::Option::None => ::bstack_raii::WidePtr::NULL,
})
} else {
quote!(|__f: #fty|
::bstack_raii::registry::home_relative_repr(__f.repr(), allocator.stack()))
};
parts
.data_variants
.push(quote!(#vname(::std::vec::Vec<#fty>),));
parts
.view_variants
.push(quote!(#vname(::std::vec::Vec<#fty>),));
parts.new_arms.push(quote! {
#data::#vname(__list) => {
let __ptrs: ::std::vec::Vec<::bstack_raii::WidePtr> =
__list.into_iter().map(#to_ptr).collect();
let __desc = #store::from_slice(allocator, &__ptrs)?.descriptor();
let mut __pl = [0u8; #payload_const];
__pl[..16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__desc));
(#disc, __pl)
}
});
parts.read_arms.push(quote! {
#disc => #view::#vname(
unsafe { #store::from_desc(#read_desc, allocator) }
.to_vec()?.into_iter().map(#from_ptr_e)
.collect::<::std::io::Result<::std::vec::Vec<_>>>()?),
});
parts.move_arms.push(quote! {
#disc => {
let __out: ::std::vec::Vec<#fty_mv> =
unsafe { #store::from_desc(#read_desc, __alloc) }
.to_vec()?.into_iter().map(#from_ptr_mv)
.collect::<::std::io::Result<::std::vec::Vec<_>>>()?;
unsafe { #store::from_desc(#read_desc, __alloc) }.bstack_drop()?;
#data::#vname(__out)
}
});
let elem_drop = foreign_elem_drop(kind, ftarget);
let drop_loop = if matches!(kind, Kind::Ref) {
quote!()
} else {
quote!(for __fp in unsafe { #store::from_desc(#read_desc, allocator) }.to_vec()? {
#elem_drop
})
};
parts.drop_arms.push(quote! {
#disc => {
#drop_loop
unsafe { #store::from_desc(#read_desc, allocator) }.bstack_drop()?;
}
});
let elem_clone = foreign_elem_clone(kind, ftarget);
parts.clone_arms.push(quote! {
#disc => {
let __src = unsafe { #store::from_desc(#read_desc, allocator) }.to_vec()?;
let mut __new: ::std::vec::Vec<::bstack_raii::WidePtr> =
::std::vec::Vec::with_capacity(__src.len());
for __fp in __src {
#elem_clone
__new.push(__newfp);
}
let __newdesc = __plan.stage_bytevec(
allocator, ::bstack_raii::bytemuck::cast_slice(&__new))?;
__pl[..16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__newdesc));
}
});
return Ok(Some(parts));
}
if kind == Kind::Pod {
let elem: TokenStream = if vec_info(ty).is_some_and(|vi| vi.is_string) {
quote!(u8)
} else {
let vi = vec_inner(ty).unwrap();
quote!(#vi)
};
parts.has_shared = true;
parts.has_weak = true;
parts
.data_variants
.push(quote!(#vname(::bstack_raii::BStackVec<'__e, #elem, __A>),));
parts
.view_variants
.push(quote!(#vname(::bstack_raii::BStackVec<'__e, #elem, __A>),));
parts.new_arms.push(quote! {
#data::#vname(__v) => {
let __desc = __v.descriptor();
let mut __pl = [0u8; #payload_const];
__pl[..16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__desc));
(#disc, __pl)
}
});
parts.read_arms.push(quote! {
#disc => #view::#vname(
unsafe { ::bstack_raii::BStackVec::<#elem, __A>::from_field(::bstack_raii::NonNullOffset::from_field(#payload_loc)?, allocator) }?),
});
parts.move_arms.push(quote! {
#disc => #data::#vname(
unsafe { ::bstack_raii::BStackVec::<#elem, __A>::from_desc(
#read_desc, __alloc) }),
});
parts.drop_arms.push(quote! {
#disc => {
unsafe { ::bstack_raii::BStackVec::<#elem, __A>::from_desc(
#read_desc, allocator) }.bstack_drop()?;
}
});
parts.clone_arms.push(quote! {
#disc => {
let __srcdesc = #read_desc;
let __newdesc = unsafe { ::bstack_raii::BStackVec::<#elem, __A>::from_desc(
__srcdesc, allocator) }.clone_data_into(__plan)?;
__pl[..16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__newdesc));
}
});
return Ok(Some(parts));
}
if vec_info(ty).is_some_and(|vi| vi.is_string) {
return Err(Error::new_spanned(
ty,
"[BSTACK0107] `String` is always POD; drop the ownership annotation to store \
it as a POD `V(String)` variant",
));
}
let is_weak = kind == Kind::Weak;
let vec_ty = match kind {
Kind::Owned => quote!(BStackBlockVec),
Kind::Strong => quote!(BStackStrongVec),
Kind::Weak => quote!(BStackWeakVec),
Kind::Ref => quote!(BStackRefVec),
_ => unreachable!(),
};
let velem = vec_inner(ty).unwrap();
let (dims, elem, leaf_nullable) = if let Type::Array(_) = velem {
array_shape(velem)?
} else {
(Vec::new(), velem, false)
};
let is_array = !dims.is_empty();
let size_elem = quote!(::core::mem::size_of::<
<#elem as ::bstack_raii::BStackBlock>::OnDisk>() as u64);
if !is_array || matches!(kind, Kind::Strong | Kind::Weak) {
parts.has_shared = true;
}
if !is_array || is_weak {
parts.has_weak = true;
}
parts.drop_arms.push(quote! {
#disc => {
unsafe { ::bstack_raii::#vec_ty::<#elem, __A>::from_desc(#read_desc, allocator) }
.bstack_drop()?;
}
});
let clone_expr = match kind {
Kind::Owned => quote!(
unsafe { ::bstack_raii::BStackBlockVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan, |__er, __p| {
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(__er) }
.__bstack_clone_into(allocator, __p)
})?),
Kind::Strong => quote!(
unsafe { ::bstack_raii::BStackStrongVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan)?),
Kind::Weak => quote!(
unsafe { ::bstack_raii::BStackWeakVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan)?),
Kind::Ref => quote!(
unsafe { ::bstack_raii::BStackRefVec::<#elem, __A>::from_desc(__srcdesc, allocator) }
.clone_into(__plan)?),
_ => unreachable!(),
};
parts.clone_arms.push(quote! {
#disc => {
let __srcdesc = #read_desc;
let __newdesc = #clone_expr;
__pl[..16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__newdesc));
}
});
if !is_array {
parts
.data_variants
.push(quote!(#vname(::bstack_raii::#vec_ty<'__e, #elem, __A>),));
parts
.view_variants
.push(quote!(#vname(::bstack_raii::#vec_ty<'__e, #elem, __A>),));
parts.new_arms.push(quote! {
#data::#vname(__v) => {
let __desc = __v.descriptor();
let mut __pl = [0u8; #payload_const];
__pl[..16].copy_from_slice(
::bstack_raii::bytemuck::bytes_of(&__desc));
(#disc, __pl)
}
});
parts.read_arms.push(quote! {
#disc => #view::#vname(
unsafe { ::bstack_raii::#vec_ty::<#elem, __A>::from_field(::bstack_raii::NonNullOffset::from_field(#payload_loc)?, allocator) }?),
});
parts.move_arms.push(quote! {
#disc => #data::#vname(
unsafe { ::bstack_raii::#vec_ty::<#elem, __A>::from_desc(
#read_desc, __alloc) }),
});
return Ok(Some(parts));
}
let total = dims_prod(&dims);
let ctrl_ty = quote!(<#elem as ::bstack_raii::BStackWeakable>::Control);
let ctrl_size = quote!(::core::mem::size_of::<
<#elem as ::bstack_raii::BStackWeakable>::Control>() as u64);
let view_leaf = if is_weak {
quote!(::core::option::Option<
::bstack_raii::BStackRc<'__e, #elem, __A>>)
} else if leaf_nullable {
quote!(::core::option::Option<#elem>)
} else {
quote!(#elem)
};
let view_read = |k: &Ident| {
if is_weak {
quote!({
let __o = __grp[#k];
if __o == 0 { ::core::option::Option::None } else {
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__o, #ctrl_size)) };
let __wk = unsafe {
::bstack_raii::BStackWeak::<#elem, __A>::from_raw(
__ctrl, allocator) };
let __up = __wk.upgrade()?;
let _ = __wk.into_raw();
__up
}
})
} else if leaf_nullable {
quote!({
let __o = __grp[#k];
if __o == 0 { ::core::option::Option::None } else {
::core::option::Option::Some(
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__o, #size_elem)) })
}
})
} else {
quote!(unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__grp[#k], #size_elem)) })
}
};
let view_build = nested_build(&dims, &view_leaf, &view_read);
let view_ret = nested_ty(&dims, &view_leaf);
parts
.view_variants
.push(quote!(#vname(::std::vec::Vec<#view_ret>),));
let own_leaf_base = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__e, #elem, __A>),
Kind::Weak => quote!(::bstack_raii::BStackWeak<'__e, #elem, __A>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem>),
_ => unreachable!(),
};
let own_leaf = if leaf_nullable {
quote!(::core::option::Option<#own_leaf_base>)
} else {
own_leaf_base.clone()
};
let data_ty = nested_ty(&dims, &own_leaf);
parts
.data_variants
.push(quote!(#vname(::std::vec::Vec<#data_ty>),));
let off_of = |h: &Ident| match kind {
Kind::Owned => quote!({
let __h = #h.into_inner();
::bstack_raii::BStackBlock::range(&__h).start()
}),
Kind::Strong => quote!({
let (__d, _c) = #h.into_raw();
__d.into_range().start()
}),
Kind::Weak => quote!(#h.into_raw().into_range().start()),
Kind::Ref => quote!(#h.into_range().start()),
_ => unreachable!(),
};
let leaf_write = |_k: &Ident, leaf: &Ident| {
if leaf_nullable {
let hh = format_ident!("__h");
let off = off_of(&hh);
quote!(__flat.push(match #leaf {
::core::option::Option::Some(#hh) => #off,
::core::option::Option::None => 0u64,
});)
} else {
let off = off_of(leaf);
quote!(__flat.push(#off);)
}
};
let consume_one = nested_consume(&dims, "e!(__a), &leaf_write);
parts.new_arms.push(quote! {
#data::#vname(__list) => {
let mut __flat: ::std::vec::Vec<u64> = ::std::vec::Vec::new();
for __a in __list {
#consume_one
}
let __desc = ::bstack_raii::BStackVec::<u64, __A>::from_slice(
allocator, &__flat)?.descriptor();
let mut __pl = [0u8; #payload_const];
__pl[..16].copy_from_slice(::bstack_raii::bytemuck::bytes_of(&__desc));
(#disc, __pl)
}
});
parts.read_arms.push(quote! {
#disc => {
let __flat = unsafe { ::bstack_raii::BStackVec::<u64, __A>::from_desc(
#read_desc, allocator) }.to_vec()?;
let mut __out = ::std::vec::Vec::with_capacity(__flat.len() / (#total));
for __grp in __flat.chunks(#total) {
__out.push(#view_build);
}
#view::#vname(__out)
}
});
let move_read = |k: &Ident| {
let one = match kind {
Kind::Owned => quote!(unsafe {
::bstack_raii::BStackOwned::from_raw(
unsafe { <#elem as ::bstack_raii::BStackBlock>::from_range(
::bstack_raii::BStackRange::new(__o, #size_elem)) })
}),
Kind::Ref => quote!(unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__o, #size_elem))
}),
Kind::Strong => quote!({
let __data = unsafe {
::bstack_raii::BStackRef::<#elem>::from_range(
::bstack_raii::BStackRange::new(__o, #size_elem)) };
let (__d, __c) =
<#elem as ::bstack_raii::BStackShared>::strong_parts(__data, __alloc)?;
unsafe { ::bstack_raii::BStackRc::from_raw(__d, __c, __alloc) }
}),
Kind::Weak => quote!({
let __ctrl = unsafe {
::bstack_raii::BStackRef::<#ctrl_ty>::from_range(
::bstack_raii::BStackRange::new(__o, #ctrl_size)) };
unsafe { ::bstack_raii::BStackWeak::from_raw(__ctrl, __alloc) }
}),
_ => unreachable!(),
};
if leaf_nullable {
quote!({
let __o = __grp[#k];
if __o == 0 { ::core::option::Option::None }
else { ::core::option::Option::Some(#one) }
})
} else {
quote!({ let __o = __grp[#k]; #one })
}
};
let own_leaf_base_mv = match kind {
Kind::Owned => quote!(::bstack_raii::BStackOwned<#elem>),
Kind::Strong => quote!(::bstack_raii::BStackRc<'__mv, #elem, __A>),
Kind::Weak => quote!(::bstack_raii::BStackWeak<'__mv, #elem, __A>),
Kind::Ref => quote!(::bstack_raii::BStackRef<#elem>),
_ => unreachable!(),
};
let own_leaf_mv = if leaf_nullable {
quote!(::core::option::Option<#own_leaf_base_mv>)
} else {
own_leaf_base_mv.clone()
};
let move_build = nested_build(&dims, &own_leaf_mv, &move_read);
parts.move_arms.push(quote! {
#disc => {
let __flat = unsafe { ::bstack_raii::BStackVec::<u64, __A>::from_desc(
#read_desc, __alloc) }.to_vec()?;
let mut __out = ::std::vec::Vec::with_capacity(__flat.len() / (#total));
for __grp in __flat.chunks(#total) {
__out.push(#move_build);
}
unsafe { ::bstack_raii::BStackVec::<u64, __A>::from_desc(#read_desc, __alloc) }
.bstack_drop()?;
#data::#vname(__out)
}
});
Ok(Some(parts))
}