use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{Error, Fields, Ident, ItemEnum, ItemStruct, Type};
use crate::util::*;
fn ctrl_tag_expr(name: &Ident, weak: bool) -> TokenStream {
if weak {
quote!(::core::option::Option::Some(
<#name as ::bstack_raii::BStackWeakable>::control_eightcc()))
} else {
quote!(::core::option::Option::None)
}
}
pub fn expand_struct(attr: TokenStream, input: ItemStruct) -> syn::Result<TokenStream> {
if !input.generics.params.is_empty() {
return Err(Error::new_spanned(
&input.generics,
"[BSTACK0408] a generic #[bstack_class] is not supported: RTTI needs a single \
concrete on-disk layout to describe. Use a concrete type, or #[bstack_block] \
without RTTI.",
));
}
let parsed = parse_attr(attr.clone())?;
let rc = parsed.mode != Mode::Plain;
let weak = parsed.mode == Mode::RcWeak;
let name = &input.ident;
let on_disk = format_ident!("{}OnDisk", name);
let mut rtti_fields: Vec<TokenStream> = Vec::new();
let mut static_pod_types: Vec<Type> = Vec::new();
let mut has_static = false;
match &input.fields {
Fields::Named(named) => {
for f in &named.named {
let fname = f.ident.clone().expect("named field");
let fname_str = fname.to_string();
if let Some(expr) = bstack_static_expr(&f.attrs) {
has_static = true;
let expr = expr.map_err(|_| {
Error::new_spanned(
f,
format!(
"[BSTACK0010] field `{fname_str}`: `#[bstack_static]` needs an \
initial value, e.g. `#[bstack_static(0u32)]`"
),
)
})?;
if classify(f)? != Kind::Pod {
return Err(Error::new_spanned(
f,
format!(
"[BSTACK0010] field `{fname_str}`: a `#[bstack_static]` class \
variable must be POD — it cannot also own a block \
(`#[bstack_owned/strong/weak/ref]` / `#[embed]`)"
),
));
}
static_pod_types.push(f.ty.clone());
rtti_fields.push(class_field(
&fname_str,
&f.ty,
is_bstack_mut(&f.attrs),
&expr,
));
} else {
let kind = classify(f)?;
let shape = field_shape(&fname_str, &f.ty, kind)?;
rtti_fields.push(instance_field(&fname_str, &on_disk, &fname, shape));
}
}
}
Fields::Unnamed(unnamed) => {
for (i, f) in unnamed.unnamed.iter().enumerate() {
if is_bstack_static(&f.attrs) {
return Err(Error::new_spanned(
f,
"[BSTACK0010] `#[bstack_static]` class variables are only supported on \
named struct fields",
));
}
let fname = format_ident!("field{i}");
let kind = classify(f)?;
let shape = field_shape(&fname.to_string(), &f.ty, kind)?;
rtti_fields.push(instance_field(&i.to_string(), &on_disk, &fname, shape));
}
}
Fields::Unit => {}
}
let instance_input = if has_static {
let mut cloned = input.clone();
if let Fields::Named(named) = &mut cloned.fields {
named.named = named
.named
.iter()
.filter(|f| !is_bstack_static(&f.attrs))
.cloned()
.collect();
}
cloned
} else {
input.clone()
};
let block_ts = crate::block::expand(attr, instance_input)?;
let name_str = name.to_string();
let ctrl_tag_expr = ctrl_tag_expr(name, weak);
let rtti_type = quote! {
::bstack_raii::rtti::RttiType {
tag: <#name as ::bstack_raii::BStackCast>::eightcc(),
name: ::std::string::String::from(#name_str),
rc: #rc,
weak: #weak,
ctrl_tag: #ctrl_tag_expr,
ondisk_size: ::core::mem::size_of::<#on_disk>() as u64,
body: ::bstack_raii::rtti::RttiBody::Struct(::std::vec![
#(#rtti_fields),*
].into()),
}
};
let reg_ts = registration(name, rtti_type);
let pod_assert = pod_assertion(&static_pod_types);
Ok(quote! {
#block_ts
#pod_assert
#reg_ts
})
}
pub fn expand_enum(attr: TokenStream, input: ItemEnum) -> syn::Result<TokenStream> {
if !input.generics.params.is_empty() {
return Err(Error::new_spanned(
&input.generics,
"[BSTACK0408] a generic #[bstack_class] is not supported: RTTI needs a single \
concrete on-disk layout to describe. Use a concrete type, or #[bstack_enum] \
without RTTI.",
));
}
let parsed = parse_attr(attr.clone())?;
let rc = parsed.mode != Mode::Plain;
let weak = parsed.mode == Mode::RcWeak;
let disc = crate::layout::discriminants(&input.variants, &parsed.repr)?;
let disc_ty = &disc.ty;
let name = &input.ident;
let on_disk = format_ident!("{}OnDisk", name);
let mut variant_toks: Vec<TokenStream> = Vec::with_capacity(input.variants.len());
for (variant, value) in input.variants.iter().zip(disc.values.iter()) {
variant_toks.push(enum_variant(variant, *value)?);
}
let block_ts = crate::enum_::expand_enum(attr, input.clone())?;
let name_str = name.to_string();
let ctrl_tag_expr = ctrl_tag_expr(name, weak);
let rtti_type = quote! {
::bstack_raii::rtti::RttiType {
tag: <#name as ::bstack_raii::BStackCast>::eightcc(),
name: ::std::string::String::from(#name_str),
rc: #rc,
weak: #weak,
ctrl_tag: #ctrl_tag_expr,
ondisk_size: ::core::mem::size_of::<#on_disk>() as u64,
body: ::bstack_raii::rtti::RttiBody::Enum(::bstack_raii::rtti::RttiEnum {
disc_width: ::core::mem::size_of::<#disc_ty>() as u8,
disc_off: ::core::mem::offset_of!(#on_disk, __bstack_disc) as u16,
payload_off: ::core::mem::offset_of!(#on_disk, __bstack_payload) as u16,
variants: ::std::vec![
#(#variant_toks),*
].into(),
}),
}
};
let reg_ts = registration(name, rtti_type);
Ok(quote! {
#block_ts
#reg_ts
})
}
fn enum_variant(variant: &syn::Variant, value: i128) -> syn::Result<TokenStream> {
let vname = variant.ident.to_string();
let disc = value as i64;
let kind = classify_attrs(&variant.attrs)?;
let fields: Vec<TokenStream> = match variant.fields.len() {
0 => Vec::new(),
1 => {
let f = variant.fields.iter().next().unwrap();
let fname = f
.ident
.as_ref()
.map(|id| id.to_string())
.unwrap_or_else(|| "0".to_string());
let shape = field_shape(&fname, &f.ty, kind)?;
vec![quote! {
::bstack_raii::rtti::RttiField {
name: ::std::string::String::from(#fname),
offset: 0u32,
shape: #shape,
}
}]
}
_ => {
let mut preceding: Vec<&Type> = Vec::new();
let mut out = Vec::with_capacity(variant.fields.len());
for (i, f) in variant.fields.iter().enumerate() {
let fname = f
.ident
.as_ref()
.map(|id| id.to_string())
.unwrap_or_else(|| i.to_string());
let ty = &f.ty;
let offset = if preceding.is_empty() {
quote!(0u32)
} else {
let sizes = preceding
.iter()
.map(|t| quote!(::core::mem::size_of::<#t>()));
quote!(::bstack_raii::rtti::rtti_narrow_u32(#(#sizes)+*, "field offset"))
};
out.push(quote! {
::bstack_raii::rtti::RttiField {
name: ::std::string::String::from(#fname),
offset: #offset,
shape: ::bstack_raii::rtti::Shape::Pod {
width: ::bstack_raii::rtti::rtti_narrow_u32(::core::mem::size_of::<#ty>(), "POD field width"),
},
}
});
preceding.push(ty);
}
out
}
};
Ok(quote! {
::bstack_raii::rtti::RttiVariant {
name: ::std::string::String::from(#vname),
disc_value: #disc,
fields: ::std::vec![
#(#fields),*
].into(),
}
})
}
fn kind_variant(kind: Kind) -> Option<TokenStream> {
Some(match kind {
Kind::Owned => quote!(Owned),
Kind::Strong => quote!(Strong),
Kind::Weak => quote!(Weak),
Kind::Ref => quote!(Ref),
Kind::Embed => quote!(Embed),
Kind::Pod => return None,
})
}
fn instance_field(name: &str, on_disk: &Ident, fname: &Ident, shape: TokenStream) -> TokenStream {
quote! {
::bstack_raii::rtti::RttiField {
name: ::std::string::String::from(#name),
offset: ::bstack_raii::rtti::rtti_narrow_u32(::core::mem::offset_of!(#on_disk, #fname), "field offset"),
shape: #shape,
}
}
}
fn class_field(name: &str, ty: &Type, mutable: bool, expr: &syn::Expr) -> TokenStream {
quote! {
::bstack_raii::rtti::RttiField {
name: ::std::string::String::from(#name),
offset: 0u32,
shape: ::bstack_raii::rtti::Shape::Class {
mutable: #mutable,
inner: ::std::boxed::Box::new(::bstack_raii::rtti::Shape::Pod {
width: ::bstack_raii::rtti::rtti_narrow_u32(::core::mem::size_of::<#ty>(), "class-variable width"),
}),
value: {
let __v: #ty = #expr;
::bstack_raii::bytemuck::bytes_of(&__v).into()
},
},
}
}
}
fn pod_assertion(types: &[Type]) -> TokenStream {
if types.is_empty() {
return quote!();
}
quote! {
const _: fn() = || {
fn __assert_static_pod<__T: ::bstack_raii::Pod>() {}
#( __assert_static_pod::<#types>(); )*
};
}
}
fn registration(name: &Ident, rtti_type: TokenStream) -> TokenStream {
let build_fn = format_ident!("__bstack_rtti_build_{}", name);
let reg_static = format_ident!("__BSTACK_RTTI_REG_{}", name);
quote! {
#[doc(hidden)]
#[allow(non_snake_case)]
fn #build_fn() -> ::bstack_raii::rtti::RttiType {
#rtti_type
}
#[doc(hidden)]
#[allow(non_upper_case_globals)]
#[::bstack_raii::rtti::distributed_slice_reexport(::bstack_raii::rtti::RTTI_TYPES)]
#[linkme(crate = ::bstack_raii::rtti::linkme)]
static #reg_static: ::bstack_raii::rtti::RttiRegistration =
::bstack_raii::rtti::RttiRegistration { build: #build_fn };
}
}
fn field_shape(fname: &str, ty: &Type, kind: Kind) -> syn::Result<TokenStream> {
if let Some(inner) = option_inner(ty) {
if kind == Kind::Pod && vec_info(inner).is_none() {
return Ok(quote!(::bstack_raii::rtti::Shape::Pod {
width: ::bstack_raii::rtti::rtti_narrow_u32(::core::mem::size_of::<#ty>(), "POD field width"),
}));
}
let inner_shape = leaf_or_container_shape(fname, ty, inner, kind)?;
return Ok(
quote!(::bstack_raii::rtti::Shape::Option(::std::boxed::Box::new(#inner_shape))),
);
}
leaf_or_container_shape(fname, ty, ty, kind)
}
fn vec_region_shape(
fname: &str,
orig: &Type,
ty: &Type,
kind: Kind,
) -> Option<syn::Result<TokenStream>> {
let vi = vec_info(ty)?;
Some((|| {
if vi.is_string {
return Ok(quote!(::bstack_raii::rtti::Shape::Vec(
::std::boxed::Box::new(::bstack_raii::rtti::Shape::Pod { width: 1 })
)));
}
let elem = vec_inner(ty).expect("vec_info matched");
let elem_shape = leaf_shape(fname, orig, elem, kind)?;
Ok(quote!(::bstack_raii::rtti::Shape::Vec(::std::boxed::Box::new(#elem_shape))))
})())
}
fn leaf_or_container_shape(
fname: &str,
orig: &Type,
ty: &Type,
kind: Kind,
) -> syn::Result<TokenStream> {
if let Some(r) = vec_region_shape(fname, orig, ty, kind) {
return r;
}
if matches!(ty, Type::Array(_)) {
let (dims, leaf, nullable) = array_shape(ty)?;
let mut acc = leaf_shape(fname, orig, leaf, kind)?;
if nullable && kind != Kind::Pod {
acc = quote!(::bstack_raii::rtti::Shape::Option(::std::boxed::Box::new(#acc)));
}
for dim in dims.iter().rev() {
acc = quote!(::bstack_raii::rtti::Shape::Array {
n: ::bstack_raii::rtti::rtti_narrow_u32(#dim, "array length"),
inner: ::std::boxed::Box::new(#acc),
});
}
return Ok(acc);
}
leaf_shape(fname, orig, ty, kind)
}
fn foreign_kind_variant(kind: Kind) -> Option<TokenStream> {
Some(match kind {
Kind::Owned => quote!(Owned),
Kind::Strong => quote!(Strong),
Kind::Weak => quote!(Weak),
Kind::Ref => quote!(Ref),
Kind::Pod | Kind::Embed => return None,
})
}
fn leaf_shape(fname: &str, orig: &Type, ty: &Type, kind: Kind) -> syn::Result<TokenStream> {
if let Some(r) = vec_region_shape(fname, orig, ty, kind) {
return r;
}
if let Some(target) = foreign_inner(ty) {
let fk = foreign_kind_variant(kind).ok_or_else(|| {
Error::new_spanned(
orig,
format!(
"[BSTACK0302] field `{fname}`: a `Foreign` needs an ownership annotation \
(#[bstack_owned/strong/weak/ref])"
),
)
})?;
return Ok(quote!(::bstack_raii::rtti::Shape::Foreign {
tag: <#target as ::bstack_raii::BStackCast>::eightcc(),
kind: ::bstack_raii::rtti::OwnershipKind::#fk,
}));
}
if let Type::Tuple(tup) = ty {
let has_foreign = tup
.elems
.iter()
.any(|e| foreign_inner(option_inner(e).unwrap_or(e)).is_some());
let fk = if has_foreign {
Some(foreign_kind_variant(kind).ok_or_else(|| {
Error::new_spanned(
orig,
format!(
"[BSTACK0302] field `{fname}`: a tuple containing a `Foreign` needs an \
ownership annotation (#[bstack_owned/strong/weak/ref]) naming the \
foreign elements' kind"
),
)
})?)
} else {
None
};
let mut elems = Vec::with_capacity(tup.elems.len());
for e in &tup.elems {
let es = if let Some(target) = foreign_inner(option_inner(e).unwrap_or(e)) {
let fk = fk.clone().expect("foreign member ⇒ has_foreign");
let leaf = quote!(::bstack_raii::rtti::Shape::Foreign {
tag: <#target as ::bstack_raii::BStackCast>::eightcc(),
kind: ::bstack_raii::rtti::OwnershipKind::#fk,
});
if option_inner(e).is_some() {
quote!(::bstack_raii::rtti::Shape::Option(::std::boxed::Box::new(#leaf)))
} else {
leaf
}
} else {
quote!(::bstack_raii::rtti::Shape::Pod {
width: ::bstack_raii::rtti::rtti_narrow_u32(::core::mem::size_of::<#e>(), "tuple element width"),
})
};
elems.push(es);
}
return Ok(quote!(::bstack_raii::rtti::Shape::Tuple(
::std::vec![#(#elems),*].into()
)));
}
Ok(match kind {
Kind::Pod => quote!(::bstack_raii::rtti::Shape::Pod {
width: ::bstack_raii::rtti::rtti_narrow_u32(::core::mem::size_of::<#ty>(), "POD field width"),
}),
other => {
let variant = kind_variant(other).expect("non-POD kind");
quote!(::bstack_raii::rtti::Shape::#variant(
<#ty as ::bstack_raii::BStackCast>::eightcc()
))
}
})
}