use proc_macro2::TokenStream;
use quote::quote;
use crate::generated::descriptor::{FileDescriptorProto, FileDescriptorSet};
pub(crate) fn reflectable_impl(ty: &TokenStream, buffa_path: &TokenStream) -> TokenStream {
quote! {
impl ::buffa_descriptor::reflect::Reflectable for #ty {
fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> {
let pool = #buffa_path::reflect::descriptor_pool();
let idx = pool
.message_index(<Self as ::buffa::MessageName>::FULL_NAME)
.unwrap_or_else(|| panic!(
"type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)",
<Self as ::buffa::MessageName>::FULL_NAME,
));
::buffa_descriptor::reflect::ReflectCow::Owned(
::buffa::alloc::boxed::Box::new(
::buffa_descriptor::reflect::DynamicMessage::from_message(
self,
::buffa::alloc::sync::Arc::clone(pool),
idx,
),
),
)
}
}
}
}
pub(crate) fn reflect_element_impl_bridge(ty: &TokenStream) -> TokenStream {
quote! {
impl ::buffa_descriptor::reflect::ReflectElement for #ty {
fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> {
::buffa_descriptor::reflect::ValueRef::Message(
::buffa_descriptor::reflect::Reflectable::reflect(self),
)
}
}
}
}
pub(crate) fn reflectable_impl_vtable(ty: &TokenStream) -> TokenStream {
quote! {
impl ::buffa_descriptor::reflect::Reflectable for #ty {
#[inline]
fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> {
::buffa_descriptor::reflect::ReflectCow::Borrowed(self)
}
}
}
}
pub(crate) fn encode_fds_once(file_descriptors: &[FileDescriptorProto]) -> Vec<u8> {
use buffa::Message;
let mut files = file_descriptors.to_vec();
for file in &mut files {
file.source_code_info = Default::default();
}
FileDescriptorSet {
file: files,
..Default::default()
}
.encode_to_vec()
}
pub(crate) fn reflect_pool_module(fds_bytes: &[u8]) -> TokenStream {
let fds_bytes_literal = proc_macro2::Literal::byte_string(fds_bytes);
quote! {
pub mod reflect {
pub const FILE_DESCRIPTOR_SET_BYTES: &[u8] = #fds_bytes_literal;
pub fn descriptor_pool() -> &'static ::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> {
static POOL: ::std::sync::OnceLock<
::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool>,
> = ::std::sync::OnceLock::new();
POOL.get_or_init(|| {
let options = ::buffa::DecodeOptions::new()
.with_element_memory_limit(
FILE_DESCRIPTOR_SET_BYTES
.len()
.saturating_mul(64)
.max(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT),
);
::buffa::alloc::sync::Arc::new(
::buffa_descriptor::DescriptorPool::decode_with_options(
FILE_DESCRIPTOR_SET_BYTES,
&options,
)
.expect("buffa-codegen emitted a linkable FileDescriptorSet"),
)
})
}
}
}
}
pub(crate) const SHARED_ROOT_MOD: &str = "__buffa_fds";
pub(crate) enum FdsSource<'a> {
Inline(&'a [u8]),
IncludeBytes(TokenStream),
}
pub(crate) fn shared_root_module(source: FdsSource<'_>) -> TokenStream {
let const_value = match source {
FdsSource::Inline(fds_bytes) => {
let literal = proc_macro2::Literal::byte_string(fds_bytes);
quote! { #literal }
}
FdsSource::IncludeBytes(arg) => quote! { include_bytes!(#arg) },
};
let root = quote::format_ident!("{SHARED_ROOT_MOD}");
quote! {
pub mod #root {
pub const FILE_DESCRIPTOR_SET_BYTES: &[u8] = #const_value;
pub fn descriptor_pool() -> &'static ::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> {
static POOL: ::std::sync::OnceLock<
::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool>,
> = ::std::sync::OnceLock::new();
POOL.get_or_init(|| {
let options = ::buffa::DecodeOptions::new()
.with_element_memory_limit(
FILE_DESCRIPTOR_SET_BYTES
.len()
.saturating_mul(64)
.max(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT),
);
::buffa::alloc::sync::Arc::new(
::buffa_descriptor::DescriptorPool::decode_with_options(
FILE_DESCRIPTOR_SET_BYTES,
&options,
)
.expect("buffa-codegen emitted a linkable FileDescriptorSet"),
)
})
}
}
}
}
fn shared_pool_supers(package: &str) -> usize {
let segments = if package.is_empty() {
0
} else {
package.split('.').count()
};
segments + 2
}
fn shared_root_path(package: &str, root_override: Option<&str>) -> TokenStream {
if let Some(root) = root_override {
return crate::idents::rust_path_to_tokens(root);
}
let root = quote::format_ident!("{SHARED_ROOT_MOD}");
let mut path = quote! { #root };
for _ in 0..shared_pool_supers(package) {
path = quote! { super::#path };
}
path
}
pub(crate) fn reflect_pool_module_shared(
package: &str,
root_override: Option<&str>,
) -> TokenStream {
let root = shared_root_path(package, root_override);
quote! {
pub mod reflect {
pub use #root::FILE_DESCRIPTOR_SET_BYTES;
pub fn descriptor_pool() -> &'static ::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> {
#root::descriptor_pool()
}
}
}
}
pub(crate) fn reflect_reexports(buffa_path: &TokenStream, gate: Option<&str>) -> TokenStream {
let reexport = |docs: &[&str], name: TokenStream| {
crate::feature_gates::cfg_block(
quote! {
#(#[doc = #docs])*
#[doc(inline)]
pub use self::#buffa_path::reflect::#name;
},
gate,
)
};
let pool = reexport(
&[
"The lazily-built descriptor pool for this package's",
"`Reflectable` impls. Re-exported from `__buffa::reflect`.",
],
quote! { descriptor_pool },
);
let fds_bytes = reexport(
&[
"The serialized `FileDescriptorSet` this package's descriptor",
"pool is built from (`source_code_info` stripped).",
"Re-exported from `__buffa::reflect`.",
],
quote! { FILE_DESCRIPTOR_SET_BYTES },
);
quote! {
#pool
#fds_bytes
}
}
const _: usize = {
0
};
#[cfg(test)]
mod tests {
use super::*;
use quote::format_ident;
#[test]
fn reflectable_impl_emits_well_formed_tokens() {
let ty = format_ident!("Person");
let ty_ts = quote! { #ty };
let buffa = quote! { __buffa };
let tokens = reflectable_impl(&ty_ts, &buffa);
let parsed = syn::parse2::<syn::ItemImpl>(tokens.clone());
assert!(parsed.is_ok(), "generated impl must parse: {tokens}");
}
#[test]
fn reflect_pool_module_emits_well_formed_tokens() {
let fd = FileDescriptorProto {
name: Some("test.proto".into()),
package: Some("test".into()),
..Default::default()
};
let bytes = encode_fds_once(&[fd]);
{
use buffa::Message;
let decoded =
FileDescriptorSet::decode_from_slice(&bytes).expect("encoded FDS round-trips");
assert_eq!(decoded.file.len(), 1);
assert_eq!(decoded.file[0].name.as_deref(), Some("test.proto"));
}
let tokens = reflect_pool_module(&bytes);
let parsed = syn::parse2::<syn::ItemMod>(tokens.clone());
assert!(parsed.is_ok(), "generated module must parse: {tokens}");
assert!(tokens.to_string().contains("FILE_DESCRIPTOR_SET_BYTES"));
let code = tokens.to_string().replace(' ', "");
assert!(
code.contains(".saturating_mul(64).max(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT)"),
"descriptor_pool() must floor its scaled bound at \
DEFAULT_ELEMENT_MEMORY_LIMIT (#336): {tokens}"
);
}
#[test]
fn reflect_pool_module_emits_one_token_regardless_of_fds_size() {
let small = reflect_pool_module(&[0u8; 8]);
let large = reflect_pool_module(&[0u8; 1_000_000]);
fn count_tokens_recursive(ts: TokenStream) -> usize {
ts.into_iter()
.map(|tt| match tt {
proc_macro2::TokenTree::Group(g) => 1 + count_tokens_recursive(g.stream()),
_ => 1,
})
.sum()
}
assert_eq!(
count_tokens_recursive(small),
count_tokens_recursive(large.clone()),
"token count must not scale with the FDS byte length"
);
let decoded = syn::parse2::<syn::ItemMod>(large)
.expect("generated module must parse")
.content
.expect("module must have a body")
.1;
let konst = decoded
.iter()
.find_map(|item| match item {
syn::Item::Const(c) if c.ident == "FILE_DESCRIPTOR_SET_BYTES" => Some(c),
_ => None,
})
.expect("FILE_DESCRIPTOR_SET_BYTES const must be present");
let syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::ByteStr(bs),
..
}) = konst.expr.as_ref()
else {
panic!("expected a byte-string literal for FILE_DESCRIPTOR_SET_BYTES");
};
assert_eq!(bs.value(), vec![0u8; 1_000_000]);
}
#[test]
fn reflect_reexports_emit_well_formed_tokens() {
let buffa = quote! { __buffa };
let tokens = reflect_reexports(&buffa, None);
let parsed = syn::parse2::<syn::File>(tokens.clone());
let file = parsed.expect("generated re-exports must parse");
assert_eq!(file.items.len(), 2, "pool accessor + FDS bytes constant");
assert!(
file.items.iter().all(|i| matches!(i, syn::Item::Use(_))),
"both items must be `use` re-exports"
);
let rendered = tokens.to_string();
assert!(rendered.contains("descriptor_pool"));
assert!(rendered.contains("FILE_DESCRIPTOR_SET_BYTES"));
}
#[test]
fn reflect_reexports_gate_each_item() {
let buffa = quote! { __buffa };
let tokens = reflect_reexports(&buffa, Some("reflect"));
let file = syn::parse2::<syn::File>(tokens).expect("gated re-exports must parse");
assert_eq!(file.items.len(), 2);
for item in &file.items {
let syn::Item::Use(item_use) = item else {
panic!("expected a use item");
};
assert!(
item_use.attrs.iter().any(|a| a.path().is_ident("cfg")),
"re-export missing its own #[cfg] gate"
);
}
}
#[test]
fn shared_pool_supers_counts_package_depth_plus_two() {
assert_eq!(shared_pool_supers(""), 2, "root package: __buffa + reflect");
assert_eq!(shared_pool_supers("foo"), 3);
assert_eq!(shared_pool_supers("foo.v1"), 4);
assert_eq!(shared_pool_supers("a.b.c.d"), 6);
}
#[test]
fn reflect_pool_module_shared_delegates_without_embedding_bytes() {
let tokens = reflect_pool_module_shared("foo.v1", None);
let parsed = syn::parse2::<syn::ItemMod>(tokens.clone());
assert!(parsed.is_ok(), "generated module must parse: {tokens}");
let rendered = tokens.to_string();
assert!(
rendered.contains("__buffa_fds"),
"shared pool must reference the root module: {rendered}"
);
assert!(
rendered.contains("super :: super :: super :: super :: __buffa_fds"),
"delegation path must climb package depth + 2 supers: {rendered}"
);
assert!(
!rendered.contains("FILE_DESCRIPTOR_SET_BYTES : & [u8] ="),
"shared mode must not embed a per-package descriptor set: {rendered}"
);
assert!(rendered.contains("FILE_DESCRIPTOR_SET_BYTES"));
assert!(rendered.contains("descriptor_pool"));
}
#[test]
fn reflect_pool_module_shared_with_root_override_uses_it_verbatim() {
let tokens =
reflect_pool_module_shared("foo.v1", Some("::my_shared_fds_crate::__buffa_fds"));
let parsed = syn::parse2::<syn::ItemMod>(tokens.clone());
assert!(parsed.is_ok(), "generated module must parse: {tokens}");
let rendered = tokens.to_string();
assert!(
rendered.contains(":: my_shared_fds_crate :: __buffa_fds"),
"root override must be used verbatim, not super::: {rendered}"
);
assert!(
!rendered.contains("super ::"),
"external-crate mode must not climb the (nonexistent) module tree: {rendered}"
);
}
#[test]
fn shared_root_module_inline_uses_a_byte_string_literal() {
let bytes = encode_fds_once(&[FileDescriptorProto {
name: Some("test.proto".into()),
package: Some("test".into()),
..Default::default()
}]);
let tokens = shared_root_module(FdsSource::Inline(&bytes));
let parsed = syn::parse2::<syn::ItemMod>(tokens.clone())
.unwrap_or_else(|_| panic!("root module must parse: {tokens}"));
let rendered = tokens.to_string();
assert!(rendered.contains("__buffa_fds"), "{rendered}");
assert!(rendered.contains("descriptor_pool"));
assert!(!rendered.contains("include_bytes"));
let items = parsed.content.expect("root module must have a body").1;
let konst = items
.iter()
.find_map(|item| match item {
syn::Item::Const(c) if c.ident == "FILE_DESCRIPTOR_SET_BYTES" => Some(c),
_ => None,
})
.expect("root module must define FILE_DESCRIPTOR_SET_BYTES");
let syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::ByteStr(literal),
..
}) = konst.expr.as_ref()
else {
panic!("inline root must use one byte-string literal: {rendered}");
};
assert_eq!(literal.value(), bytes);
}
#[test]
fn shared_root_module_floors_its_scaled_element_memory_limit() {
let rendered = shared_root_module(FdsSource::Inline(&[1, 2, 3])).to_string();
let flat: String = rendered.chars().filter(|c| !c.is_whitespace()).collect();
assert!(
flat.contains(
"FILE_DESCRIPTOR_SET_BYTES.len().saturating_mul(64).max(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT)"
),
"shared pool must floor its scaled element-memory bound: {rendered}"
);
assert!(
flat.contains("DescriptorPool::decode_with_options(FILE_DESCRIPTOR_SET_BYTES,&options"),
"shared pool must decode with the generated options: {rendered}"
);
}
#[test]
fn shared_root_module_include_bytes_references_sidecar() {
let tokens = shared_root_module(FdsSource::IncludeBytes(quote! { "descriptor_set.binpb" }));
let parsed = syn::parse2::<syn::ItemMod>(tokens.clone());
assert!(parsed.is_ok(), "root module must parse: {tokens}");
let rendered = tokens.to_string();
assert!(rendered.contains("__buffa_fds"));
assert!(rendered.contains("include_bytes !"), "{rendered}");
assert!(rendered.contains("descriptor_set.binpb"), "{rendered}");
assert!(
!rendered.contains("FILE_DESCRIPTOR_SET_BYTES : & [u8] = b\""),
"include_bytes mode must not inline the bytes: {rendered}"
);
}
#[test]
fn encode_fds_once_strips_source_code_info() {
use crate::generated::descriptor::SourceCodeInfo;
let fd = FileDescriptorProto {
name: Some("test.proto".into()),
package: Some("test".into()),
source_code_info: SourceCodeInfo::default().into(),
..Default::default()
};
assert!(fd.source_code_info.is_set());
let bytes = encode_fds_once(&[fd]);
use buffa::Message;
let decoded =
FileDescriptorSet::decode_from_slice(&bytes).expect("encoded FDS round-trips");
assert_eq!(decoded.file.len(), 1);
assert!(
!decoded.file[0].source_code_info.is_set(),
"source_code_info must not survive into the embedded FDS"
);
}
}