use std::collections::{BTreeMap, HashMap, HashSet};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use crate::context::{ancillary_prefix, AncillaryKind, MessageScope};
use crate::generated::descriptor::field_descriptor_proto::Type;
use crate::generated::descriptor::{DescriptorProto, FieldDescriptorProto};
use crate::idents::rust_path_to_tokens;
use crate::message::classify_field;
use crate::table_plan::{
table_fields, type_stem, Card, MapField, OneofMembership, PlainField, Shape, TableField,
};
use crate::CodeGenError;
fn table_ident(rust_name: &str) -> proc_macro2::Ident {
format_ident!("__BUFFA_TABLE_{}", rust_name)
}
fn table_path(type_path: &str) -> Result<TokenStream, CodeGenError> {
if type_path.starts_with("::") || type_path.starts_with("crate::") {
return Err(CodeGenError::Other(format!(
"table codec: message type `{type_path}` is generated by another crate, \
so it has no table here"
)));
}
let (head, last) = match type_path.rsplit_once("::") {
Some((head, last)) => (format!("{head}::"), last),
None => (String::new(), type_path),
};
Ok(rust_path_to_tokens(&format!("{head}__BUFFA_TABLE_{last}")))
}
pub(crate) const TABLE_ABI: u32 = 1;
pub(crate) fn generate_table_impl(
scope: MessageScope<'_>,
msg: &DescriptorProto,
rust_name: &str,
resolver: &crate::imports::ImportResolver,
) -> Result<TokenStream, CodeGenError> {
let MessageScope {
ctx,
proto_fqn,
features,
..
} = scope;
let name = format_ident!("{}", rust_name);
let table = table_ident(rust_name);
let dotted_fqn = format!(".{proto_fqn}");
let deprecated_field_allow = crate::message::deprecated_field_allow(ctx, msg, proto_fqn);
let fields = table_fields(ctx, msg, &dotted_fqn, features).map_err(|why| {
CodeGenError::Other(format!(
"table codec: {dotted_fqn} cannot use the table: {}",
why.detail
))
})?;
let mut entries: Vec<TokenStream> = Vec::with_capacity(fields.len());
let mut aux: Vec<TokenStream> = Vec::new();
let mut oneofs = Oneofs::new(scope, msg, &fields)?;
for f in &fields {
if let Shape::Plain(
plain @ PlainField {
oneof: Some(member),
..
},
) = &f.shape
{
entries.push(oneofs.member_entry(scope, &name, f, plain, member, &mut aux)?);
continue;
}
let (entry, aux_item) = field_entry(scope, msg, &name, f, aux.len(), resolver)?;
entries.push(entry);
aux.extend(aux_item);
}
let oneof_impls = oneofs.into_impls();
let dense = dense_lookup(&fields, &dotted_fqn)?;
let abi = proc_macro2::Literal::u32_unsuffixed(TABLE_ABI);
let unknown = if ctx.preserve_unknown_fields(proto_fqn) {
quote! { __buffa_unknown_fields }
} else {
quote! { none }
};
Ok(quote! {
#[doc(hidden)]
#[allow(non_upper_case_globals)]
#deprecated_field_allow
pub(crate) static #table: ::buffa::table::Table<#name> = ::buffa::__table!(
#name,
abi = #abi,
entries = [#(#entries),*],
dense = &[#(#dense),*],
aux = [#(#aux),*],
unknown = #unknown,
);
impl ::buffa::Message for #name {
fn compute_size(&self, cache: &mut ::buffa::SizeCache) -> u32 {
#table.compute_size(self, cache)
}
fn write_to(&self, cache: &mut ::buffa::SizeCache, buf: &mut impl ::buffa::EncodeSink) {
#table.write_to(self, cache, buf);
}
fn merge_field(
&mut self,
tag: ::buffa::encoding::Tag,
buf: &mut impl ::buffa::bytes::Buf,
ctx: ::buffa::DecodeContext<'_>,
) -> ::core::result::Result<(), ::buffa::DecodeError> {
#table.merge_field(self, tag, buf, ctx)
}
fn merge_to_limit(
&mut self,
buf: &mut impl ::buffa::bytes::Buf,
ctx: ::buffa::DecodeContext<'_>,
limit: usize,
) -> ::core::result::Result<(), ::buffa::DecodeError> {
#table.merge_to_limit(self, buf, ctx, limit)
}
fn merge_length_delimited(
&mut self,
buf: &mut impl ::buffa::bytes::Buf,
ctx: ::buffa::DecodeContext<'_>,
) -> ::core::result::Result<(), ::buffa::DecodeError> {
#table.merge_length_delimited(self, buf, ctx)
}
fn clear(&mut self) {
*self = ::core::default::Default::default();
}
}
#(#oneof_impls)*
})
}
fn dense_lookup(fields: &[TableField<'_>], dotted_fqn: &str) -> Result<Vec<u8>, CodeGenError> {
let top = fields
.iter()
.map(|f| f.number)
.filter(|&n| n < 64)
.max()
.unwrap_or(0) as usize;
let mut dense = vec![0u8; top + 1];
for (i, f) in fields.iter().enumerate() {
if let Some(slot) = dense.get_mut(f.number as usize) {
*slot = u8::try_from(i + 1).map_err(|_| {
CodeGenError::Other(format!(
"table codec: {dotted_fqn} has more than 255 fields numbered {} or \
lower, so its field numbers are not distinct",
f.number
))
})?;
}
}
Ok(dense)
}
fn field_entry(
scope: MessageScope<'_>,
msg: &DescriptorProto,
name: &proc_macro2::Ident,
f: &TableField<'_>,
aux_index: usize,
resolver: &crate::imports::ImportResolver,
) -> Result<(TokenStream, Option<TokenStream>), CodeGenError> {
let MessageScope { ctx, .. } = scope;
let field = f.field;
let field_name = field.name.as_deref().unwrap_or("");
let ident = ctx.field_ident(field_name, field.number.unwrap_or(0));
let number = f.number;
let aux_u16 = || u16::try_from(aux_index).map_err(|_| too_many_descriptors(scope));
let type_path = |what: &str| type_path(scope, field, what);
let unshortened_path = || unshortened_path(scope, field);
let type_name = || field_type_name(field);
let plain = match &f.shape {
Shape::Map(map) => {
let aux = aux_u16()?;
let map_ty = classify_field(scope, msg, field, resolver)?.rust_type;
let vt = map_descriptor(scope, &map_ty, map)?;
return Ok((
quote! {
::buffa::__table_entry!(#name, #ident, Map, #number, aux = #aux, slot = #map_ty)
},
Some(quote! { ::buffa::table::Aux::Map(&#vt) }),
));
}
Shape::Plain(plain) => plain,
};
let kind = format_ident!("{}", plain.kind);
match plain.ty {
Type::TYPE_MESSAGE => {
let child = type_path("message")?;
let child_ty = rust_path_to_tokens(&child);
let child_table = if ctx.uses_table_codec(type_name()?) {
Some(table_path(&unshortened_path()?)?)
} else {
None
};
let (slot, aux_item) = if plain.card == Card::Repeated {
let vt = match &child_table {
Some(table) => quote! { ::buffa::table::RepVt::new::<#child_ty>(&#table) },
None => quote! { ::buffa::table::RepVt::new_via_message::<#child_ty>() },
};
(
quote! { ::buffa::alloc::vec::Vec<#child_ty> },
quote! { ::buffa::table::Aux::Rep(&#vt) },
)
} else {
let slot = classify_field(scope, msg, field, resolver)?.rust_type;
let vt = match &child_table {
Some(table) => quote! { ::buffa::table::MsgVt::new::<#slot>(&#table) },
None => quote! { ::buffa::table::MsgVt::new_via_message::<#slot>() },
};
(slot, quote! { ::buffa::table::Aux::Msg(&#vt) })
};
let aux = aux_u16()?;
Ok((
quote! {
::buffa::__table_entry!(#name, #ident, #kind, #number, aux = #aux, slot = #slot)
},
Some(aux_item),
))
}
Type::TYPE_ENUM => {
let enum_ty = rust_path_to_tokens(&type_path("enum")?);
let repeated = matches!(plain.card, Card::Repeated | Card::Packed);
let shape = match (repeated, plain.card == Card::Optional, plain.closed_enum) {
(true, _, true) => quote! { RepeatedClosed },
(true, _, false) => quote! { RepeatedOpen },
(false, true, true) => quote! { OptionalClosed },
(false, true, false) => quote! { OptionalOpen },
(false, false, true) => quote! { ImplicitClosed },
(false, false, false) => quote! { ImplicitOpen },
};
let shape = quote! { ::buffa::table::#shape<#enum_ty> };
let aux = aux_u16()?;
Ok((
quote! {
::buffa::__table_entry!(
#name, #ident, #kind, #number,
aux = #aux,
slot = <#shape as ::buffa::table::EnumShape>::Slot
)
},
Some(quote! {
::buffa::table::Aux::Enum(&::buffa::table::EnumVt::new::<#shape>())
}),
))
}
_ => Ok((
quote! { ::buffa::__table_entry!(#name, #ident, #kind, #number) },
None,
)),
}
}
fn map_descriptor(
scope: MessageScope<'_>,
map_ty: &TokenStream,
map: &MapField<'_>,
) -> Result<TokenStream, CodeGenError> {
let marker = |ty: Type, slot: &str| -> Result<TokenStream, CodeGenError> {
match type_stem(ty, Card::Required) {
Some(stem) if !matches!(ty, Type::TYPE_ENUM | Type::TYPE_MESSAGE) => {
let kind = format_ident!("{}Required", stem);
Ok(quote! { ::buffa::table::kinds::#kind })
}
_ => Err(CodeGenError::Other(format!(
"table codec: a map {slot} of type {ty:?} has no scalar kind"
))),
}
};
let key = marker(map.key_ty, "key")?;
Ok(match map.val_ty {
Type::TYPE_ENUM => {
let enum_ty = rust_path_to_tokens(&type_path(scope, map.val_field, "enum")?);
let shape = if map.closed_enum {
quote! { ImplicitClosed }
} else {
quote! { ImplicitOpen }
};
quote! {
::buffa::table::MapVt::with_enum::<#map_ty, #key, ::buffa::table::#shape<#enum_ty>>()
}
}
Type::TYPE_MESSAGE => {
let child = rust_path_to_tokens(&type_path(scope, map.val_field, "message")?);
let msg_vt = if scope.ctx.uses_table_codec(field_type_name(map.val_field)?) {
let child_table = table_path(&unshortened_path(scope, map.val_field)?)?;
quote! { ::buffa::table::DirectMsgVt::new(&#child_table) }
} else {
quote! { ::buffa::table::DirectMsgVt::<#child>::via_message() }
};
quote! {
::buffa::table::MapVt::with_msg::<#map_ty, #key, #child>(&#msg_vt)
}
}
ty => {
let value = marker(ty, "value")?;
quote! { ::buffa::table::MapVt::new::<#map_ty, #key, #value>() }
}
})
}
fn field_type_name(field: &FieldDescriptorProto) -> Result<&str, CodeGenError> {
field
.type_name
.as_deref()
.ok_or(CodeGenError::MissingField("field.type_name"))
}
fn too_many_descriptors(scope: MessageScope<'_>) -> CodeGenError {
CodeGenError::Other(format!(
"table codec: {}: a message has more than 65535 fields that need a descriptor",
scope.proto_fqn
))
}
fn type_path(
scope: MessageScope<'_>,
field: &FieldDescriptorProto,
what: &str,
) -> Result<String, CodeGenError> {
let type_name = field_type_name(field)?;
scope
.ctx
.rust_type_relative(type_name, scope.current_package, scope.nesting)
.ok_or_else(|| CodeGenError::Other(format!("{what} type '{type_name}' not found")))
}
fn unshortened_path(
scope: MessageScope<'_>,
field: &FieldDescriptorProto,
) -> Result<String, CodeGenError> {
let type_name = field_type_name(field)?;
let split = scope
.ctx
.rust_type_relative_split(type_name, scope.current_package, scope.nesting)
.ok_or_else(|| CodeGenError::Other(format!("message type '{type_name}' not found")))?;
Ok(if split.to_package.is_empty() {
split.within_package
} else {
format!("{}::{}", split.to_package, split.within_package)
})
}
#[derive(Default)]
struct OneofArms {
number: Vec<TokenStream>,
payload: Vec<TokenStream>,
payload_mut: Vec<TokenStream>,
with_default: Vec<TokenStream>,
}
struct Oneofs {
prefix: TokenStream,
enum_idents: HashMap<usize, proc_macro2::Ident>,
first: HashMap<usize, u32>,
with_messages: HashSet<usize>,
group_aux: HashMap<usize, usize>,
payload_aux: HashMap<String, usize>,
arms: BTreeMap<usize, OneofArms>,
}
impl Oneofs {
fn new(
scope: MessageScope<'_>,
msg: &DescriptorProto,
fields: &[TableField<'_>],
) -> Result<Self, CodeGenError> {
let mut first: HashMap<usize, u32> = HashMap::new();
let mut with_messages = HashSet::new();
for (oneof, f, plain) in fields.iter().filter_map(|f| match &f.shape {
Shape::Plain(plain) => plain.oneof.as_ref().map(|oneof| (oneof, f, plain)),
Shape::Map(_) => None,
}) {
let lowest = first.entry(oneof.index).or_insert(f.number);
*lowest = (*lowest).min(f.number);
if plain.ty == Type::TYPE_MESSAGE {
with_messages.insert(oneof.index);
}
}
Ok(Self {
prefix: ancillary_prefix(
scope.ctx,
AncillaryKind::Oneof,
scope.current_package,
scope.proto_fqn,
scope.nesting,
),
enum_idents: crate::oneof::resolve_oneof_idents(msg, scope.proto_fqn)?,
first,
with_messages,
group_aux: HashMap::new(),
payload_aux: HashMap::new(),
arms: BTreeMap::new(),
})
}
fn shared_aux(&mut self, aux: &mut Vec<TokenStream>, item: TokenStream) -> usize {
*self.payload_aux.entry(item.to_string()).or_insert_with(|| {
aux.push(item);
aux.len() - 1
})
}
fn member_entry(
&mut self,
scope: MessageScope<'_>,
message: &proc_macro2::Ident,
f: &TableField<'_>,
plain: &PlainField<'_>,
member: &OneofMembership<'_>,
aux: &mut Vec<TokenStream>,
) -> Result<TokenStream, CodeGenError> {
let ctx = scope.ctx;
let field = f.field;
let field_name = field.name.as_deref().unwrap_or("");
let too_many = || too_many_descriptors(scope);
let enum_ident = self.enum_idents.get(&member.index).ok_or_else(|| {
CodeGenError::Other(format!(
"table codec: {}.{field_name}: the oneof `{}` has no enum",
scope.proto_fqn, member.name
))
})?;
let prefix = &self.prefix;
let enum_path = quote! { #prefix #enum_ident };
let oneof_field = ctx.oneof_ident(member.name);
let variant = crate::oneof::oneof_variant_ident(field_name);
let number = f.number;
let payload_kind = format_ident!("{}", plain.kind);
let first = self.first[&member.index];
let group = match self.group_aux.get(&member.index) {
Some(&group) => group,
None => {
let ctor = if self.with_messages.contains(&member.index) {
format_ident!("with_messages")
} else {
format_ident!("new")
};
aux.push(quote! {
::buffa::table::Aux::Group(&::buffa::table::OneofVt::#ctor::<#enum_path>(
::buffa::table::offset_of!(#message, #oneof_field),
#first,
))
});
self.group_aux.insert(member.index, aux.len() - 1);
aux.len() - 1
}
};
let variant_fqn = format!(".{}.{}.{field_name}", scope.proto_fqn, member.name);
let default = quote! { ::core::default::Default::default() };
let (slot, value_aux, new) = match plain.ty {
Type::TYPE_MESSAGE => {
let child = rust_path_to_tokens(&type_path(scope, field, "message")?);
let msg_vt = if ctx.uses_table_codec(field_type_name(field)?) {
let child_table = table_path(&unshortened_path(scope, field)?)?;
quote! { ::buffa::table::MsgVt::direct::<#child>(&#child_table) }
} else {
quote! { ::buffa::table::MsgVt::direct_via_message::<#child>() }
};
let new = if crate::oneof::variant_boxed(ctx, plain.ty, &variant_fqn) {
match ctx.pointer_repr(&variant_fqn) {
crate::PointerRepr::Box => quote! { ::buffa::alloc::boxed::Box::default() },
repr => repr.pointer_new(&child, &default)?,
}
} else {
default
};
(
child,
Some(quote! { ::buffa::table::Aux::Msg(&#msg_vt) }),
new,
)
}
Type::TYPE_ENUM => {
let enum_ty = rust_path_to_tokens(&type_path(scope, field, "enum")?);
let shape = if plain.closed_enum {
quote! { ::buffa::table::ImplicitClosed<#enum_ty> }
} else {
quote! { ::buffa::table::ImplicitOpen<#enum_ty> }
};
(
quote! { <#shape as ::buffa::table::EnumShape>::Slot },
Some(
quote! { ::buffa::table::Aux::Enum(&::buffa::table::EnumVt::new::<#shape>()) },
),
default,
)
}
_ => (
quote! { <::buffa::table::kinds::#payload_kind as ::buffa::table::KindSlot>::Slot },
None,
default,
),
};
let value_aux = value_aux.map_or(Ok(0), |item| {
u16::try_from(self.shared_aux(aux, item)).map_err(|_| too_many())
})?;
let arms = self.arms.entry(member.index).or_default();
arms.number.push(quote! { Self::#variant(_) => #number, });
arms.payload.push(quote! {
Self::#variant(v) => {
let value: &#slot = v;
let ptr: *const #slot = value;
ptr.cast::<u8>()
}
});
arms.payload_mut.push(quote! {
Self::#variant(v) => {
let value: &mut #slot = v;
let ptr: *mut #slot = value;
ptr.cast::<u8>()
}
});
arms.with_default
.push(quote! { #number => ::core::option::Option::Some(Self::#variant(#new)), });
let leader = number == first;
let group = u16::try_from(group).map_err(|_| too_many())?;
aux.push(quote! {
::buffa::table::Aux::Member(::buffa::table::Member::new(
#group,
::buffa::table::Kind::#payload_kind,
#value_aux,
))
});
let member_aux = u16::try_from(aux.len() - 1).map_err(|_| too_many())?;
Ok(quote! {
::buffa::__table_entry!(
#message, #oneof_field, oneof(#payload_kind, #leader), #number,
aux = #member_aux,
slot = ::core::option::Option<#enum_path>
)
})
}
fn into_impls(self) -> Vec<TokenStream> {
let prefix = self.prefix;
self.arms
.into_iter()
.map(|(index, arms)| {
let enum_ident = &self.enum_idents[&index];
let OneofArms {
number,
payload,
payload_mut,
with_default,
} = arms;
quote! {
impl ::buffa::table::OneofEnum for #prefix #enum_ident {
fn number(&self) -> u32 {
match self {
#(#number)*
}
}
fn payload(&self) -> *const u8 {
match self {
#(#payload)*
}
}
fn payload_mut(&mut self) -> *mut u8 {
match self {
#(#payload_mut)*
}
}
fn with_default(number: u32) -> ::core::option::Option<Self> {
match number {
#(#with_default)*
_ => ::core::option::Option::None,
}
}
}
}
})
.collect()
}
}