use proc_macro2::TokenStream;
use syn::{Field, Ident, Type, Visibility};
use crate::util::Kind;
#[derive(Clone, Copy)]
pub(crate) struct FieldCtx<'a> {
pub vis: &'a Visibility,
pub name: &'a Ident,
pub fname: &'a Ident,
pub field: &'a Field,
pub kind: Kind,
pub on_disk_ty: &'a TokenStream,
pub type_params: &'a [&'a Ident],
pub const_params: &'a [&'a Ident],
}
#[derive(Clone, Copy)]
pub(crate) struct VariantCtx<'a> {
pub vname: &'a Ident,
pub disc: &'a TokenStream,
pub kind: Kind,
pub data: &'a Ident,
pub view: &'a Ident,
pub on_disk: &'a Ident,
pub payload_const: &'a Ident,
}
#[derive(Default)]
pub(crate) struct Usage {
pub pod: bool,
pub blockish: bool,
pub strong: bool,
pub weak: bool,
pub in_ondisk: bool,
pub foreign_owned: bool,
pub foreign: bool,
pub embed: bool,
}
#[derive(Default)]
pub(crate) struct EUsage {
pub strong: bool,
pub weak: bool,
pub foreign_owned: bool,
pub foreign: bool,
}
#[derive(Default)]
pub(crate) struct VariantParts {
pub data_variants: Vec<TokenStream>,
pub view_variants: Vec<TokenStream>,
pub new_arms: Vec<TokenStream>,
pub read_arms: Vec<TokenStream>,
pub move_arms: Vec<TokenStream>,
pub raw_arms: Vec<TokenStream>,
pub drop_arms: Vec<TokenStream>,
pub clone_arms: Vec<TokenStream>,
pub payload_sizes: Vec<TokenStream>,
pub pod_types: Vec<Type>,
pub embed_types: Vec<TokenStream>,
pub has_embed: bool,
pub needs_payload: bool,
pub has_shared: bool,
pub has_weak: bool,
pub has_foreign: bool,
}
impl VariantParts {
pub fn merge(&mut self, other: VariantParts) {
self.data_variants.extend(other.data_variants);
self.view_variants.extend(other.view_variants);
self.new_arms.extend(other.new_arms);
self.read_arms.extend(other.read_arms);
self.move_arms.extend(other.move_arms);
self.drop_arms.extend(other.drop_arms);
self.raw_arms.extend(other.raw_arms);
self.clone_arms.extend(other.clone_arms);
self.payload_sizes.extend(other.payload_sizes);
self.pod_types.extend(other.pod_types);
self.embed_types.extend(other.embed_types);
self.has_embed |= other.has_embed;
self.needs_payload |= other.needs_payload;
self.has_shared |= other.has_shared;
self.has_weak |= other.has_weak;
self.has_foreign |= other.has_foreign;
}
}
#[derive(Default)]
pub(crate) struct FieldParts {
pub on_disk_fields: Vec<TokenStream>,
pub accessors: Vec<TokenStream>,
pub setters: Vec<TokenStream>,
pub ctor_params: Vec<TokenStream>,
pub ctor_preps: Vec<TokenStream>,
pub ctor_inits: Vec<TokenStream>,
pub ctor_handback: Vec<TokenStream>,
pub ctor_handback_ty: Vec<TokenStream>,
pub ctor_post: Vec<TokenStream>,
pub drop_stmts: Vec<TokenStream>,
pub clone_stmts: Vec<TokenStream>,
pub mv_caps: Vec<TokenStream>,
pub mv_types: Vec<TokenStream>,
pub mv_recon: Vec<TokenStream>,
pub wrapper_defs: Vec<TokenStream>,
pub pod_types: Vec<Type>,
pub ref_coerced: bool,
}
impl FieldParts {
pub fn merge(&mut self, other: FieldParts) {
self.on_disk_fields.extend(other.on_disk_fields);
self.accessors.extend(other.accessors);
self.setters.extend(other.setters);
self.ctor_params.extend(other.ctor_params);
self.ctor_preps.extend(other.ctor_preps);
self.ctor_inits.extend(other.ctor_inits);
self.ctor_handback.extend(other.ctor_handback);
self.ctor_handback_ty.extend(other.ctor_handback_ty);
self.ctor_post.extend(other.ctor_post);
self.drop_stmts.extend(other.drop_stmts);
self.clone_stmts.extend(other.clone_stmts);
self.mv_caps.extend(other.mv_caps);
self.mv_types.extend(other.mv_types);
self.mv_recon.extend(other.mv_recon);
self.wrapper_defs.extend(other.wrapper_defs);
self.pod_types.extend(other.pod_types);
self.ref_coerced |= other.ref_coerced;
}
}