use crate::generated::descriptor::field_descriptor_proto::{Label, Type};
use crate::generated::descriptor::DescriptorProto;
use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};
use crate::context::{ancillary_prefix, AncillaryKind, CodeGenContext, MessageScope};
use crate::defaults::parse_default_value;
use crate::features::ResolvedFeatures;
use crate::impl_message::{is_explicit_presence_scalar, is_real_oneof_member};
use crate::CodeGenError;
#[derive(Default)]
pub(crate) struct RegistryPaths {
pub json_any: Vec<TokenStream>,
pub text_any: Vec<TokenStream>,
pub json_ext: Vec<TokenStream>,
pub text_ext: Vec<TokenStream>,
}
impl RegistryPaths {
pub(crate) fn is_empty(&self) -> bool {
self.json_any.is_empty()
&& self.text_any.is_empty()
&& self.json_ext.is_empty()
&& self.text_ext.is_empty()
}
}
#[derive(Default)]
pub(crate) struct MessageOutput {
pub owned_top: TokenStream,
pub owned_mod: TokenStream,
pub oneof_tree: TokenStream,
pub view_tree: TokenStream,
pub lazy_view_tree: TokenStream,
pub view_oneof_tree: TokenStream,
pub reg: RegistryPaths,
}
pub(crate) fn generate_message(
ctx: &CodeGenContext,
msg: &DescriptorProto,
current_package: &str,
rust_name: &str,
proto_fqn: &str,
features: &ResolvedFeatures,
resolver: &crate::imports::ImportResolver,
) -> Result<MessageOutput, CodeGenError> {
let scope = MessageScope {
ctx,
current_package,
proto_fqn,
features,
nesting: 0,
};
generate_message_with_nesting(scope, msg, rust_name, resolver)
}
fn generate_message_with_nesting(
scope: MessageScope<'_>,
msg: &DescriptorProto,
rust_name: &str,
resolver: &crate::imports::ImportResolver,
) -> Result<MessageOutput, CodeGenError> {
let MessageScope {
ctx,
current_package,
proto_fqn,
features,
nesting,
} = scope;
let name_ident = format_ident!("{}", rust_name);
let sensitive_impl = crate::sensitive::message_impl(scope, msg, &name_ident, resolver)?;
let is_message_set = msg
.options
.as_option()
.and_then(|o| o.message_set_wire_format)
.unwrap_or(false);
if is_message_set && !ctx.config.allow_message_set {
return Err(CodeGenError::MessageSetNotSupported {
message_name: proto_fqn.to_string(),
});
}
let nested_enums = msg
.enum_type
.iter()
.map(|e| {
let enum_name = e.name.as_deref().unwrap_or("");
let enum_fqn = format!("{}.{}", proto_fqn, enum_name);
let enum_rust_name = ctx.config.prefixed_type_name(enum_name);
crate::enumeration::generate_enum(
ctx,
e,
&enum_rust_name,
&enum_fqn,
features,
resolver,
)
})
.collect::<Result<Vec<_>, _>>()?;
let nested_msgs = msg
.nested_type
.iter()
.filter(|nested| {
!nested
.options
.as_option()
.and_then(|o| o.map_entry)
.unwrap_or(false)
})
.map(|nested| {
let nested_proto_name = nested.name.as_deref().unwrap_or("");
let nested_fqn = format!("{}.{}", proto_fqn, nested_proto_name);
let nested_rust_name = ctx.config.prefixed_type_name(nested_proto_name);
let msg_features = crate::features::message_scope_features(features, nested, false);
generate_message_with_nesting(
scope.nested(&nested_fqn, &msg_features),
nested,
&nested_rust_name,
resolver,
)
})
.collect::<Result<Vec<_>, _>>()?;
let generated_fields: Vec<GeneratedField> = msg
.field
.iter()
.map(|f| generate_field(scope, msg, f, resolver))
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.flatten()
.collect();
let json_default_helpers = generated_fields
.iter()
.filter_map(|field| field.json_default_helper.as_ref());
let direct_fields: Vec<&TokenStream> = generated_fields.iter().map(|f| &f.tokens).collect();
let mut debug_fields: Vec<(&Ident, bool)> = generated_fields
.iter()
.map(|f| (&f.ident, f.debug_redact))
.collect();
let mut setter_methods: TokenStream = generated_fields
.iter()
.filter_map(|f| f.setter.as_ref().map(|s| (f, s)))
.map(|(f, s)| {
let field_ident = &f.ident;
let setter_ident = &s.ident;
let field_name = field_ident.to_string();
let assigned = if s.wrap_optional {
"Some(value)"
} else {
"value"
};
let doc = if let Some(stripped) = field_name.strip_prefix("r#") {
format!("Sets `{stripped}` to `{assigned}`, consuming and returning `self`.")
} else {
format!(
"Sets [`Self::{field_name}`] to `{assigned}`, consuming and returning `self`."
)
};
let value = if s.use_into {
quote! { value.into() }
} else {
quote! { value }
};
let body = if s.wrap_optional {
quote! {Some(#value)}
} else {
value
};
let erase = if ctx.zeroizes_message(proto_fqn) {
quote! {::buffa::sensitive::Zeroize::zeroize(&mut self.#field_ident);}
} else {
quote! {}
};
let param = &s.param_type;
let setter_deprecated = f.deprecated.then(|| quote! { #[deprecated] });
quote! {
#[must_use = "with_* setters return `self` by value; assign or chain the result"]
#[inline]
#[doc = #doc]
#setter_deprecated
pub fn #setter_ident(mut self, value: #param) -> Self {
#erase
self.#field_ident = #body;
self
}
}
})
.collect();
let proto_name = msg.name.as_deref().unwrap_or(rust_name);
let mod_ident = make_field_ident(&ctx.message_module_name(proto_fqn));
let oneof_idents = crate::oneof::resolve_oneof_idents(msg, proto_fqn)?;
let oneof_prefix = ancillary_prefix(
ctx,
AncillaryKind::Oneof,
current_package,
proto_fqn,
nesting,
);
let gates = ctx.config.feature_gates();
let oneof_serde_attr = if ctx.config.generate_json {
crate::feature_gates::cfg_attr(quote! { serde(flatten) }, gates.json)
} else {
quote! {}
};
let mut oneof_generated: Vec<(TokenStream, Ident)> = Vec::new();
for (idx, oneof) in msg.oneof_decl.iter().enumerate() {
let (Some(enum_ident), Some(oneof_name)) = (oneof_idents.get(&idx), oneof.name.as_deref())
else {
continue;
};
let field_ident = ctx.oneof_ident(oneof_name);
let opt = resolver.option_at(ctx, nesting);
let rename_note = ctx
.oneof_rename_note(oneof_name)
.map(|note| quote! { #[doc = #note] });
let custom_attrs = CodeGenContext::matching_attributes(
&ctx.config.oneof_struct_field_attributes,
&format!("{proto_fqn}.{oneof_name}"),
)?;
let tokens = quote! {
#rename_note
#oneof_serde_attr
#custom_attrs
pub #field_ident: #opt<#oneof_prefix #enum_ident>,
};
oneof_generated.push((tokens, field_ident));
}
let oneof_struct_fields: Vec<&TokenStream> = oneof_generated.iter().map(|(t, _)| t).collect();
debug_fields.extend(oneof_generated.iter().map(|(_, id)| (id, false)));
let has_extension_ranges = !msg.extension_range.is_empty();
let use_ext_json_wrapper =
ctx.config.generate_json && ctx.preserve_unknown_fields(proto_fqn) && has_extension_ranges;
let ext_json_wrapper_ident = format_ident!("__{}ExtJson", rust_name);
let (unknown_fields_field, ext_json_wrapper_def) = if use_ext_json_wrapper {
let arbitrary_attr = if ctx.config.generate_arbitrary {
quote! { #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))] }
} else {
quote! {}
};
let proto_fqn_lit = proto_fqn;
let serde_impls = crate::feature_gates::cfg_block(
quote! {
impl ::serde::Serialize for #ext_json_wrapper_ident {
fn serialize<__S: ::serde::Serializer>(&self, s: __S)
-> ::core::result::Result<__S::Ok, __S::Error>
{
::buffa::extension_registry::serialize_extensions(#proto_fqn_lit, &self.0, s)
}
}
},
gates.json,
);
let serde_de_impl = crate::feature_gates::cfg_block(
quote! {
impl<'de> ::serde::Deserialize<'de> for #ext_json_wrapper_ident {
fn deserialize<__D: ::serde::Deserializer<'de>>(d: __D)
-> ::core::result::Result<Self, __D::Error>
{
::buffa::extension_registry::deserialize_extensions(#proto_fqn_lit, d).map(Self)
}
}
},
gates.json,
);
let wrapper = quote! {
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#arbitrary_attr
pub struct #ext_json_wrapper_ident(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for #ext_json_wrapper_ident {
type Target = ::buffa::UnknownFields;
fn deref(&self) -> &::buffa::UnknownFields { &self.0 }
}
impl ::core::ops::DerefMut for #ext_json_wrapper_ident {
fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields { &mut self.0 }
}
impl ::core::convert::From<::buffa::UnknownFields> for #ext_json_wrapper_ident {
fn from(u: ::buffa::UnknownFields) -> Self { Self(u) }
}
#serde_impls
#serde_de_impl
};
let flatten_attr = crate::feature_gates::cfg_attr(quote! { serde(flatten) }, gates.json);
let field = quote! {
#flatten_attr
#[doc(hidden)]
pub __buffa_unknown_fields: #ext_json_wrapper_ident,
};
(field, wrapper)
} else if ctx.preserve_unknown_fields(proto_fqn) {
let skip_attr = if ctx.config.generate_json {
crate::feature_gates::cfg_attr(quote! { serde(skip) }, gates.json)
} else {
quote! {}
};
let field = quote! {
#skip_attr
#[doc(hidden)]
pub __buffa_unknown_fields: ::buffa::UnknownFields,
};
(field, quote! {})
} else {
(quote! {}, quote! {})
};
let has_real_oneofs = !oneof_struct_fields.is_empty();
let needs_custom_deserialize = ctx.config.generate_json
&& (has_real_oneofs
|| ctx.zeroizes_message(proto_fqn)
|| (has_extension_ranges && ctx.preserve_unknown_fields(proto_fqn)));
let deny_unknown_json_fields = scope.deny_unknown_json_fields();
let oneof_enums = msg
.oneof_decl
.iter()
.enumerate()
.map(|(idx, oneof)| {
crate::oneof::generate_oneof_enum(
ctx,
msg,
idx,
oneof,
current_package,
proto_fqn,
features,
resolver,
&oneof_idents,
nesting,
)
})
.collect::<Result<Vec<_>, _>>()?;
let table_impl = if ctx.uses_table_codec(proto_fqn) {
Some(crate::table_codec::generate_table_impl(
scope, msg, rust_name, resolver,
)?)
} else {
None
};
let message_impl = crate::impl_message::generate_message_impl(
ctx,
msg,
ctx.preserve_unknown_fields(proto_fqn),
rust_name,
current_package,
proto_fqn,
features,
&oneof_idents,
&oneof_prefix,
nesting,
table_impl,
)?;
let text_impl = crate::impl_text::generate_text_impl(
ctx,
msg,
rust_name,
current_package,
proto_fqn,
features,
has_extension_ranges,
&oneof_idents,
&oneof_prefix,
nesting,
)?;
let type_url = format!("type.googleapis.com/{proto_fqn}");
let upper =
crate::oneof::to_snake_case(&format!("{}{proto_name}", ctx.config.type_name_prefix))
.to_uppercase();
let (json_any_const, json_any_ident) = if ctx.config.generate_json {
let ident = format_ident!("__{}_JSON_ANY", upper);
let tokens = crate::feature_gates::cfg_block(
quote! {
#[doc(hidden)]
pub const #ident: ::buffa::type_registry::JsonAnyEntry
= ::buffa::type_registry::JsonAnyEntry {
type_url: #type_url,
to_json: ::buffa::type_registry::any_to_json::<#name_ident>,
from_json: ::buffa::type_registry::any_from_json::<#name_ident>,
is_wkt: false,
};
},
gates.json,
);
(tokens, Some(ident))
} else {
(quote! {}, None)
};
let (text_any_const, text_any_ident) = if ctx.config.generate_text {
let ident = format_ident!("__{}_TEXT_ANY", upper);
let tokens = crate::feature_gates::cfg_block(
quote! {
#[doc(hidden)]
pub const #ident: ::buffa::type_registry::TextAnyEntry
= ::buffa::type_registry::TextAnyEntry {
type_url: #type_url,
text_encode: ::buffa::type_registry::any_encode_text::<#name_ident>,
text_merge: ::buffa::type_registry::any_merge_text::<#name_ident>,
};
},
gates.text,
);
(tokens, Some(ident))
} else {
(quote! {}, None)
};
let serde_struct_derive = if ctx.config.generate_json {
let derives = if needs_custom_deserialize {
quote! { derive(::serde::Serialize) }
} else {
quote! { derive(::serde::Serialize, ::serde::Deserialize) }
};
let derive_attr = crate::feature_gates::cfg_attr(derives, gates.json);
let deny_unknown_attr = if !needs_custom_deserialize && deny_unknown_json_fields {
crate::feature_gates::cfg_attr(quote! { serde(deny_unknown_fields) }, gates.json)
} else {
quote! {}
};
quote! {
#derive_attr
#deny_unknown_attr
}
} else {
quote! {}
};
let arbitrary_derive = if ctx.config.generate_arbitrary && !ctx.zeroizes_message(proto_fqn) {
quote! { #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))] }
} else {
quote! {}
};
let guarded_arbitrary = if ctx.config.generate_arbitrary && ctx.zeroizes_message(proto_fqn) {
crate::guarded_arbitrary::message(
scope,
msg,
&name_ident,
&oneof_idents,
&oneof_prefix,
resolver,
)?
} else {
quote! {}
};
let custom_type_attrs =
CodeGenContext::matching_attributes(&ctx.config.type_attributes, proto_fqn)?;
let custom_message_attrs =
CodeGenContext::matching_attributes(&ctx.config.message_attributes, proto_fqn)?;
let custom_deserialize = if needs_custom_deserialize {
crate::feature_gates::cfg_block(
generate_custom_deserialize(
scope,
msg,
&name_ident,
&oneof_prefix,
resolver,
has_extension_ranges,
&oneof_idents,
)?,
gates.json,
)
} else {
quote! {}
};
let proto_elem_json_impl = if ctx.config.generate_json {
crate::feature_gates::cfg_block(
quote! {
impl ::buffa::json_helpers::ProtoElemJson for #name_ident {
fn serialize_proto_json<__S: ::serde::Serializer>(
v: &Self,
s: __S,
) -> ::core::result::Result<__S::Ok, __S::Error> {
::serde::Serialize::serialize(v, s)
}
fn deserialize_proto_json<'de, __D: ::serde::Deserializer<'de>>(
d: __D,
) -> ::core::result::Result<Self, __D::Error> {
<Self as ::serde::Deserialize>::deserialize(d)
}
}
},
gates.json,
)
} else {
quote! {}
};
let custom_default_impl = generate_custom_default(
ctx,
msg,
&name_ident,
current_package,
proto_fqn,
features,
nesting,
)?;
let derive_default = if custom_default_impl.is_some() {
quote! {}
} else {
quote! { Default, }
};
let custom_default_impl = custom_default_impl.unwrap_or_default();
let mut nested_items = TokenStream::new();
let mut nested_oneof_tree = TokenStream::new();
let mut nested_view_tree = TokenStream::new();
let mut nested_lazy_view_tree = TokenStream::new();
let mut nested_view_oneof_tree = TokenStream::new();
let mut reg_paths = RegistryPaths::default();
if let Some(id) = &json_any_ident {
reg_paths.json_any.push(quote! { #id });
}
if let Some(id) = &text_any_ident {
reg_paths.text_any.push(quote! { #id });
}
let non_map_nested: Vec<&DescriptorProto> = msg
.nested_type
.iter()
.filter(|n| {
!n.options
.as_option()
.and_then(|o| o.map_entry)
.unwrap_or(false)
})
.collect();
for (nested_desc, nested_out) in non_map_nested.iter().zip(nested_msgs) {
nested_items.extend(nested_out.owned_top);
let nested_name = nested_desc.name.as_deref().unwrap_or("");
let nested_mod_name = ctx.message_module_name(&format!("{proto_fqn}.{nested_name}"));
let nested_mod = make_field_ident(&nested_mod_name);
let nested_mod_doc = module_rename_doc(nested_name, &nested_mod_name);
for p in nested_out.reg.json_ext {
reg_paths.json_ext.push(quote! { #nested_mod :: #p });
}
for p in nested_out.reg.text_ext {
reg_paths.text_ext.push(quote! { #nested_mod :: #p });
}
for p in nested_out.reg.json_any {
reg_paths.json_any.push(quote! { #mod_ident :: #p });
}
for p in nested_out.reg.text_any {
reg_paths.text_any.push(quote! { #mod_ident :: #p });
}
if !nested_out.owned_mod.is_empty() {
let inner = nested_out.owned_mod;
nested_items.extend(quote! {
#nested_mod_doc
pub mod #nested_mod {
#[allow(unused_imports)]
use super::*;
#inner
}
});
}
nested_oneof_tree.extend(nested_out.oneof_tree);
nested_view_tree.extend(nested_out.view_tree);
nested_lazy_view_tree.extend(nested_out.lazy_view_tree);
nested_view_oneof_tree.extend(nested_out.view_oneof_tree);
}
let (nested_extensions, nested_ext_json, nested_ext_text) =
crate::extension::generate_extensions(
ctx,
&msg.extension,
current_package,
nesting + 1,
features,
proto_fqn,
)?;
for id in nested_ext_json {
reg_paths.json_ext.push(quote! { #id });
}
for id in nested_ext_text {
reg_paths.text_ext.push(quote! { #id });
}
let natural_reexports = collect_natural_reexports(scope, msg, &oneof_idents, &non_map_nested);
let owned_mod = quote! {
#(#nested_enums)*
#nested_items
#nested_extensions
#natural_reexports
};
let (own_view_top, own_view_oneofs) = if ctx.config.generate_views {
crate::view::generate_view_with_nesting(scope, msg, rust_name)?
} else {
(TokenStream::new(), TokenStream::new())
};
let own_lazy_top = if ctx.config.generate_views && ctx.config.lazy_views {
crate::lazy_view::generate_lazy_view_with_nesting(scope, msg, rust_name)?
} else {
TokenStream::new()
};
let wrap = |body: TokenStream| -> TokenStream {
if body.is_empty() {
return TokenStream::new();
}
quote! {
pub mod #mod_ident {
#[allow(unused_imports)]
use super::*;
#body
}
}
};
let oneof_tree = wrap(quote! { #(#oneof_enums)* #nested_oneof_tree });
let view_oneof_tree = wrap(quote! { #own_view_oneofs #nested_view_oneof_tree });
let view_tree = {
let nested_wrapped = wrap(nested_view_tree);
quote! { #own_view_top #nested_wrapped }
};
let lazy_view_tree = {
let nested_wrapped = wrap(nested_lazy_view_tree);
quote! { #own_lazy_top #nested_wrapped }
};
let struct_name_str = name_ident.to_string();
let debug_field_names: Vec<String> = debug_fields
.iter()
.map(|(id, _)| id.to_string().trim_start_matches("r#").to_string())
.collect();
let debug_field_values: Vec<TokenStream> = debug_fields
.iter()
.map(|(id, redacted)| {
if *redacted || ctx.zeroizes_message(proto_fqn) {
quote! { &::core::format_args!(#DEBUG_REDACT_PLACEHOLDER) }
} else {
quote! { &self.#id }
}
})
.collect();
let deprecated_field_allow = deprecated_field_allow(ctx, msg, proto_fqn);
let debug_impl = if ctx.skip_debug(proto_fqn) {
quote! {}
} else {
quote! {
#deprecated_field_allow
impl ::core::fmt::Debug for #name_ident {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_struct(#struct_name_str)
#(.field(#debug_field_names, #debug_field_values))*
.finish()
}
}
}
};
let message_doc =
crate::comments::doc_attrs_resolved(ctx.comment(proto_fqn), proto_fqn, &ctx.type_map);
let non_snake_attr = ctx.message_non_snake_attr(msg);
if ctx.zeroizes_message(proto_fqn) {
for (index, oneof) in msg.oneof_decl.iter().enumerate() {
let Some(enum_ident) = oneof_idents.get(&index) else {
continue;
};
let name = oneof
.name
.as_deref()
.ok_or(CodeGenError::MissingField("oneof.name"))?;
let field = ctx.oneof_ident(name);
let setter = format_ident!("with_{}", ctx.oneof_rust_name(name));
setter_methods.extend(quote! {
#[must_use]
pub fn #setter(mut self,value:#oneof_prefix #enum_ident)->Self {
::buffa::sensitive::Zeroize::zeroize(&mut self.#field);
self.#field=Some(value);
self
}
});
}
}
let with_setters_impl = if ctx.config.generate_with_setters && !setter_methods.is_empty() {
quote! {
#non_snake_attr
#deprecated_field_allow
impl #name_ident {
#setter_methods
}
}
} else {
quote! {}
};
let top_level = quote! {
#message_doc
#[derive(Clone, PartialEq, #derive_default)]
#serde_struct_derive
#arbitrary_derive
#custom_type_attrs
#custom_message_attrs
#non_snake_attr
pub struct #name_ident {
#(#direct_fields)*
#(#oneof_struct_fields)*
#unknown_fields_field
}
#debug_impl
#custom_default_impl
impl #name_ident {
pub const TYPE_URL: &'static str = #type_url;
#(#json_default_helpers)*
}
#with_setters_impl
#sensitive_impl
#guarded_arbitrary
#message_impl
#text_impl
#custom_deserialize
#proto_elem_json_impl
#ext_json_wrapper_def
#json_any_const
#text_any_const
};
Ok(MessageOutput {
owned_top: top_level,
owned_mod,
oneof_tree,
view_tree,
lazy_view_tree,
view_oneof_tree,
reg: reg_paths,
})
}
pub(crate) fn module_rename_doc(message_name: &str, mod_name: &str) -> TokenStream {
let base = crate::oneof::to_snake_case(message_name);
if mod_name == base {
return TokenStream::new();
}
let summary = format!("Nested items of `{message_name}`.");
let reason = format!(
"The module is named `{mod_name}` because `{base}` is not available \
in this scope: a sub-package or a generated type has that name, or \
it is one of `self`, `super`, `crate`, `arbitrary` and `oneof`."
);
quote! {
#[doc = #summary]
#[doc = ""]
#[doc = #reason]
}
}
pub(crate) struct ReexportCandidate {
pub(crate) name: String,
pub(crate) tokens: TokenStream,
}
fn collect_natural_reexports(
scope: MessageScope<'_>,
msg: &DescriptorProto,
oneof_idents: &std::collections::HashMap<usize, Ident>,
non_map_nested: &[&DescriptorProto],
) -> TokenStream {
use std::collections::BTreeSet;
let MessageScope {
ctx,
current_package,
proto_fqn,
nesting,
..
} = scope;
if !ctx.config.generate_views && oneof_idents.is_empty() {
return TokenStream::new();
}
let mut occupied: BTreeSet<String> = BTreeSet::new();
for nested in non_map_nested {
let name = nested.name.as_deref().unwrap_or("");
occupied.insert(ctx.config.prefixed_type_name(name));
occupied.insert(ctx.message_module_name(&format!("{proto_fqn}.{name}")));
}
for e in &msg.enum_type {
occupied.insert(
ctx.config
.prefixed_type_name(e.name.as_deref().unwrap_or("")),
);
}
for ext in &msg.extension {
occupied.insert(
crate::extension::extension_const_ident(ext.name.as_deref().unwrap_or("")).to_string(),
);
}
let from_nesting = nesting + 1;
let view_prefix = ancillary_prefix(
ctx,
AncillaryKind::View,
current_package,
proto_fqn,
from_nesting,
);
let oneof_prefix = ancillary_prefix(
ctx,
AncillaryKind::Oneof,
current_package,
proto_fqn,
from_nesting,
);
let view_oneof_prefix = ancillary_prefix(
ctx,
AncillaryKind::ViewOneof,
current_package,
proto_fqn,
from_nesting,
);
let lazy_view_prefix = ancillary_prefix(
ctx,
AncillaryKind::LazyView,
current_package,
proto_fqn,
from_nesting,
);
let mut candidates: Vec<ReexportCandidate> = Vec::new();
let inline = quote! { #[doc(inline)] };
let mut oneof_pairs: Vec<(usize, &Ident)> = oneof_idents.iter().map(|(k, v)| (*k, v)).collect();
oneof_pairs.sort_by_key(|(idx, _)| *idx);
for (_, enum_ident) in &oneof_pairs {
candidates.push(ReexportCandidate {
name: enum_ident.to_string(),
tokens: quote! { #inline pub use #oneof_prefix #enum_ident; },
});
}
if ctx.config.generate_views {
let views_gate = ctx.config.feature_gates().views;
for nested in non_map_nested {
let nested_rust_name = ctx
.config
.prefixed_type_name(nested.name.as_deref().unwrap_or(""));
let view_ident = format_ident!("{nested_rust_name}View");
candidates.push(ReexportCandidate {
name: view_ident.to_string(),
tokens: crate::feature_gates::cfg_block(
quote! { #inline pub use #view_prefix #view_ident; },
views_gate,
),
});
let owned_view_ident = format_ident!("{nested_rust_name}OwnedView");
candidates.push(ReexportCandidate {
name: owned_view_ident.to_string(),
tokens: crate::feature_gates::cfg_block(
quote! { #inline pub use #view_prefix #owned_view_ident; },
views_gate,
),
});
if ctx.config.lazy_views {
let lazy_ident = format_ident!("{nested_rust_name}LazyView");
candidates.push(ReexportCandidate {
name: lazy_ident.to_string(),
tokens: crate::feature_gates::cfg_block(
quote! { #inline pub use #lazy_view_prefix #lazy_ident; },
views_gate,
),
});
}
}
for (_, enum_ident) in &oneof_pairs {
let view_ident = format_ident!("{}View", enum_ident);
candidates.push(ReexportCandidate {
name: view_ident.to_string(),
tokens: crate::feature_gates::cfg_block(
quote! { #inline pub use #view_oneof_prefix #enum_ident as #view_ident; },
views_gate,
),
});
}
}
emit_surviving_reexports(candidates, &occupied)
}
pub(crate) fn emit_surviving_reexports(
candidates: Vec<ReexportCandidate>,
occupied: &std::collections::BTreeSet<String>,
) -> TokenStream {
use std::collections::BTreeMap;
let mut counts: BTreeMap<String, usize> = BTreeMap::new();
for c in &candidates {
*counts.entry(c.name.clone()).or_insert(0) += 1;
}
let mut out = TokenStream::new();
for c in candidates {
if occupied.contains(&c.name) || counts[&c.name] > 1 {
continue;
}
out.extend(c.tokens);
}
out
}
fn generate_custom_deserialize(
scope: MessageScope<'_>,
msg: &DescriptorProto,
name_ident: &proc_macro2::Ident,
oneof_prefix: &TokenStream,
resolver: &crate::imports::ImportResolver,
has_extension_ranges: bool,
oneof_idents: &std::collections::HashMap<usize, Ident>,
) -> Result<TokenStream, CodeGenError> {
let MessageScope {
ctx,
current_package,
proto_fqn,
features,
nesting,
..
} = scope;
let mut field_vars = Vec::new();
let mut match_arms = Vec::new();
let mut field_inits = Vec::new();
let mut accepted_keys: Vec<String> = Vec::new();
for field in &msg.field {
if is_real_oneof_member(field) {
continue;
}
let field_tokens = custom_deser_regular_field(scope, msg, field, resolver)?;
field_vars.push(field_tokens.var_decl);
match_arms.push(field_tokens.arm);
field_inits.push(field_tokens.field_init);
accepted_keys.extend(field_tokens.accepted_keys);
}
for (idx, oneof) in msg.oneof_decl.iter().enumerate() {
let result = custom_deser_oneof_group(
ctx,
msg,
idx,
oneof,
current_package,
proto_fqn,
oneof_prefix,
features,
resolver,
oneof_idents,
nesting,
)?;
let Some(oneof_tokens) = result else {
continue;
};
field_vars.push(oneof_tokens.var_decl);
match_arms.extend(oneof_tokens.arms);
field_inits.push(oneof_tokens.field_init);
accepted_keys.extend(oneof_tokens.accepted_keys);
}
let (ext_var, ext_arm, ext_init) =
if has_extension_ranges && ctx.preserve_unknown_fields(proto_fqn) {
let proto_fqn_lit = proto_fqn;
let var = quote! {
let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField>
= ::buffa::alloc::vec::Vec::new();
};
let arm = quote! {
__k if __k.starts_with('[') && __k.ends_with(']') => {
let ::buffa::json_helpers::buffered::BufferedValue(__v) =
map.next_value()?;
match ::buffa::extension_registry::deserialize_extension_key(
#proto_fqn_lit, __k, __v,
) {
::core::option::Option::Some(::core::result::Result::Ok(__recs)) => {
for __rec in __recs {
__ext_records.push(__rec);
}
}
::core::option::Option::Some(::core::result::Result::Err(__e)) => {
return ::core::result::Result::Err(
<__A::Error as ::serde::de::Error>::custom(__e),
);
}
::core::option::Option::None => {}
}
}
};
let init = quote! {
for __rec in __ext_records {
__r.__buffa_unknown_fields.push(__rec);
}
};
(var, arm, init)
} else {
(quote! {}, quote! {}, quote! {})
};
let guarded = ctx.zeroizes_message(proto_fqn);
let unknown_error = if guarded {
quote! {
<__A::Error as ::serde::de::Error>::custom(
::buffa::sensitive::JsonErrorReason::UnknownField
)
}
} else {
let accepted = &accepted_keys;
quote! {
<__A::Error as ::serde::de::Error>::unknown_field(
__unknown, &[#(#accepted),*]
)
}
};
let terminal_arm = if scope.deny_unknown_json_fields() {
quote! {
__unknown => {
return ::core::result::Result::Err(#unknown_error);
}
}
} else {
quote! { _ => { map.next_value::<::serde::de::IgnoredAny>()?; } }
};
let guard_key = if guarded {
quote! { let key = ::buffa::sensitive::Zeroizing::new(key); }
} else {
quote! {}
};
let read_fields = if match_arms.is_empty() && ext_arm.is_empty() {
if scope.deny_unknown_json_fields() {
if guarded {
quote! {
if let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
let _key = ::buffa::sensitive::Zeroizing::new(key);
return Err(#unknown_error);
}
}
} else {
quote! {
if let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
return Err(<__A::Error as ::serde::de::Error>::unknown_field(&key,&[]));
}
}
}
} else {
quote! {
while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
#guard_key
let _ = key;
map.next_value::<::serde::de::IgnoredAny>()?;
}
}
}
} else {
quote! {
while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
#guard_key
match key.as_str() {
#(#match_arms)*
#ext_arm
#terminal_arm
}
}
}
};
let result_mut = if msg.field.is_empty() && !scope.ctx.preserve_unknown_fields(proto_fqn) {
quote! {}
} else {
quote! { mut }
};
let result_init =
quote! { let #result_mut __r = <#name_ident as ::core::default::Default>::default(); };
let (early_result, late_result) = if ctx.zeroizes_message(proto_fqn) {
(result_init, quote! {})
} else {
(quote! {}, result_init)
};
let expecting_msg = format!("struct {name_ident}");
let non_snake_attr = ctx.message_non_snake_attr(msg);
let deprecated_field_allow = deprecated_field_allow(ctx, msg, proto_fqn);
Ok(quote! {
#non_snake_attr
#deprecated_field_allow
impl<'de> ::serde::Deserialize<'de> for #name_ident {
fn deserialize<__D: ::serde::Deserializer<'de>>(d: __D) -> ::core::result::Result<Self, __D::Error> {
struct _V;
impl<'de> ::serde::de::Visitor<'de> for _V {
type Value = #name_ident;
fn expecting(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.write_str(#expecting_msg)
}
#[allow(clippy::field_reassign_with_default)]
fn visit_map<__A: ::serde::de::MapAccess<'de>>(
self,
mut map: __A,
) -> ::core::result::Result<#name_ident, __A::Error> {
#early_result
#(#field_vars)*
#ext_var
#read_fields
#late_result
#(#field_inits)*
#ext_init
Ok(__r)
}
}
d.deserialize_map(_V)
}
}
})
}
fn deser_seed_expr(rust_type: &TokenStream, inner: TokenStream) -> TokenStream {
quote! {{
struct _S;
impl<'de> ::serde::de::DeserializeSeed<'de> for _S {
type Value = #rust_type;
fn deserialize<__D: ::serde::Deserializer<'de>>(self, d: __D)
-> ::core::result::Result<#rust_type, __D::Error>
{
#inner
}
}
map.next_value_seed(_S)?
}}
}
struct CustomDeserField {
var_decl: TokenStream,
arm: TokenStream,
field_init: TokenStream,
accepted_keys: Vec<String>,
}
struct CustomDeserOneof {
var_decl: TokenStream,
arms: Vec<TokenStream>,
field_init: TokenStream,
accepted_keys: Vec<String>,
}
fn custom_deser_regular_field(
scope: MessageScope<'_>,
msg: &DescriptorProto,
field: &crate::generated::descriptor::FieldDescriptorProto,
resolver: &crate::imports::ImportResolver,
) -> Result<CustomDeserField, CodeGenError> {
let MessageScope { ctx, features, .. } = scope;
let field_name = field
.name
.as_deref()
.ok_or(CodeGenError::MissingField("field.name"))?;
let json_name = field.json_name.as_deref().unwrap_or(field_name);
let var_ident = format_ident!(
"__f_{}",
ctx.field_rust_name(field_name, field.number.unwrap_or(0))
);
let field_ident = ctx.field_ident(field_name, field.number.unwrap_or(0));
let info = classify_field(scope, msg, field, resolver)?;
let rust_type = &info.rust_type;
let field_features = crate::features::resolve_field(ctx, field, features);
let (with_module, null_deser) = field_deser_modules(
crate::impl_message::effective_type(ctx, field, features),
&info,
&field_features,
);
let deser_expr = if is_value_field(field, info.is_repeated, info.is_map) {
let inner = quote! { ::buffa::json_helpers::message_field_always_present(d) };
deser_seed_expr(rust_type, inner)
} else if let Some(module) = with_module {
let module_path: syn::Path = syn::parse_str(module)
.map_err(|_| CodeGenError::InvalidTypePath(module.to_string()))?;
let inner = quote! { #module_path::deserialize(d) };
deser_seed_expr(rust_type, inner)
} else if null_deser.is_some() {
let inner = quote! { ::buffa::json_helpers::null_as_default(d) };
deser_seed_expr(rust_type, inner)
} else {
quote! { map.next_value::<#rust_type>()? }
};
if ctx.zeroizes_message(scope.proto_fqn) {
let keys = if json_name != field_name {
vec![json_name.to_owned(), field_name.to_owned()]
} else {
vec![json_name.to_owned()]
};
let (var_decl, duplicate_check) = if msg.field.iter().any(is_real_oneof_member) {
(quote! {}, quote! {})
} else {
(
quote! {let mut #var_ident = false;},
quote! {
if #var_ident {
return Err(<__A::Error as ::serde::de::Error>::duplicate_field(#field_name));
}
#var_ident = true;
},
)
};
return Ok(CustomDeserField {
var_decl,
field_init: quote! {},
accepted_keys: keys.clone(),
arm: quote! { #(#keys)|* => {
#duplicate_check
let value = #deser_expr;
::buffa::sensitive::Zeroize::zeroize(&mut __r.#field_ident);
__r.#field_ident = value;
} },
});
}
let (arm, accepted_keys) = if json_name != field_name {
(
quote! { #json_name | #field_name => { #var_ident = Some(#deser_expr); } },
vec![json_name.to_string(), field_name.to_string()],
)
} else {
(
quote! { #json_name => { #var_ident = Some(#deser_expr); } },
vec![json_name.to_string()],
)
};
let var_decl = quote! { let mut #var_ident: ::core::option::Option<#rust_type> = None; };
let field_init = quote! {
if let ::core::option::Option::Some(v) = #var_ident { __r.#field_ident = v; }
};
Ok(CustomDeserField {
var_decl,
arm,
field_init,
accepted_keys,
})
}
#[allow(clippy::too_many_arguments)]
fn custom_deser_oneof_group(
ctx: &CodeGenContext,
msg: &DescriptorProto,
idx: usize,
oneof: &crate::generated::descriptor::OneofDescriptorProto,
current_package: &str,
proto_fqn: &str,
oneof_prefix: &TokenStream,
features: &ResolvedFeatures,
resolver: &crate::imports::ImportResolver,
oneof_idents: &std::collections::HashMap<usize, Ident>,
nesting: usize,
) -> Result<Option<CustomDeserOneof>, CodeGenError> {
let oneof_name = oneof
.name
.as_deref()
.ok_or(CodeGenError::MissingField("oneof.name"))?;
let enum_ident = match oneof_idents.get(&idx) {
Some(id) => id.clone(),
None => return Ok(None),
};
let var_ident = format_ident!("__oneof_{}", ctx.oneof_rust_name(oneof_name));
let field_ident = ctx.oneof_ident(oneof_name);
let (var_decl, result_target) = if ctx.zeroizes_message(proto_fqn) {
(quote! {}, quote! { __r.#field_ident })
} else {
(
quote! { let mut #var_ident: ::core::option::Option<#oneof_prefix #enum_ident> = None; },
quote! { #var_ident },
)
};
let mut arms = Vec::new();
let mut accepted_keys = Vec::new();
for field in &msg.field {
if !is_real_oneof_member(field) || field.oneof_index != Some(idx as i32) {
continue;
}
let proto_name = field
.name
.as_deref()
.ok_or(CodeGenError::MissingField("field.name"))?;
let json_name = field.json_name.as_deref().unwrap_or(proto_name);
let variant_ident = crate::oneof::oneof_variant_ident(proto_name);
let field_type = crate::impl_message::effective_type(ctx, field, features);
let variant_string_repr = if field_type == Type::TYPE_STRING {
crate::impl_message::field_string_repr(ctx, proto_fqn, proto_name)
} else {
crate::StringRepr::String
};
let variant_bytes_repr = if field_type == Type::TYPE_BYTES {
crate::impl_message::field_bytes_repr(ctx, proto_fqn, proto_name)
} else {
crate::BytesRepr::Vec
};
let variant_type = if field_type == Type::TYPE_BYTES && !variant_bytes_repr.is_default() {
variant_bytes_repr.type_path(resolver, ctx, nesting)?
} else if field_type == Type::TYPE_STRING && !variant_string_repr.is_default() {
variant_string_repr.type_path(resolver, ctx, nesting)?
} else {
scalar_or_message_type_nested(ctx, field, current_package, nesting, features, resolver)?
};
let qualified_enum: TokenStream = quote! { #oneof_prefix #enum_ident };
let variant_fqn = format!(".{proto_fqn}.{oneof_name}.{proto_name}");
let variant_pointer_repr = ctx.pointer_repr(&variant_fqn);
let variant_json_policy = crate::json_policy::JsonPolicyKind::of_field(
ctx,
field_type,
&variant_bytes_repr,
&variant_string_repr,
);
let deser_input = crate::oneof::OneofVariantDeserInput {
guarded_enum: (ctx.zeroizes_message(proto_fqn) && field_type == Type::TYPE_ENUM)
.then(|| is_closed_enum(&crate::features::resolve_field(ctx, field, features))),
json_policy: variant_json_policy,
variant_ident: &variant_ident,
variant_type: &variant_type,
json_name,
proto_name,
field_type,
null_forward: crate::oneof::null_is_valid_value(field),
is_boxed: crate::oneof::variant_boxed(ctx, field_type, &variant_fqn),
pointer_repr: &variant_pointer_repr,
enum_ident: &qualified_enum,
result_var: &result_target,
oneof_name,
};
accepted_keys.extend(deser_input.accepted_keys());
arms.push(crate::oneof::oneof_variant_deser_arm(&deser_input)?);
}
let field_init = if ctx.zeroizes_message(proto_fqn) {
quote! {}
} else {
quote! { __r.#field_ident = #var_ident; }
};
Ok(Some(CustomDeserOneof {
var_decl,
arms,
field_init,
accepted_keys,
}))
}
fn is_value_field(
field: &crate::generated::descriptor::FieldDescriptorProto,
is_repeated: bool,
is_map: bool,
) -> bool {
field.r#type.unwrap_or_default() == Type::TYPE_MESSAGE
&& !is_repeated
&& !is_map
&& field.type_name.as_deref() == Some(".google.protobuf.Value")
}
fn is_wkt_wrapper_type(type_name: Option<&str>) -> bool {
matches!(
type_name,
Some(
".google.protobuf.BoolValue"
| ".google.protobuf.BytesValue"
| ".google.protobuf.DoubleValue"
| ".google.protobuf.FloatValue"
| ".google.protobuf.Int32Value"
| ".google.protobuf.Int64Value"
| ".google.protobuf.StringValue"
| ".google.protobuf.UInt32Value"
| ".google.protobuf.UInt64Value"
)
)
}
#[derive(Debug)]
pub(crate) struct FieldInfo {
guarded: bool,
pub(crate) rust_type: TokenStream,
struct_field_type: TokenStream,
is_repeated: bool,
is_custom_repeated: bool,
is_map: bool,
is_optional: bool,
bytes_repr: crate::BytesRepr,
map_value_bytes_repr: crate::BytesRepr,
string_repr: crate::StringRepr,
map_repr: crate::MapRepr,
is_required: bool,
map_key_type: Option<Type>,
map_value_type: Option<Type>,
is_wkt_wrapper: bool,
map_value_is_wkt_wrapper: bool,
map_value_enum_closed: Option<bool>,
map_key_custom_string: bool,
map_value_custom_string: bool,
json_policy: bool,
map_key_json_policy: bool,
map_value_json_policy: bool,
inner_opt_type: Option<TokenStream>,
}
impl FieldInfo {
pub(crate) fn struct_field_type(&self) -> &TokenStream {
&self.struct_field_type
}
pub(crate) fn concrete_type(&self) -> &TokenStream {
&self.rust_type
}
}
pub(crate) fn classify_field(
scope: MessageScope<'_>,
msg: &DescriptorProto,
field: &crate::generated::descriptor::FieldDescriptorProto,
resolver: &crate::imports::ImportResolver,
) -> Result<FieldInfo, CodeGenError> {
let MessageScope {
ctx,
current_package,
proto_fqn,
features,
nesting,
} = scope;
let label = field.label.unwrap_or_default();
let field_type = crate::impl_message::effective_type(ctx, field, features);
let is_repeated = label == Label::LABEL_REPEATED;
let map_entry = if is_repeated {
find_map_entry(msg, field)
} else {
None
};
let is_map = map_entry.is_some();
let is_optional = is_explicit_presence_scalar(field, field_type, features);
let is_required = crate::impl_message::is_required_field(field, features);
let field_name = field.name.as_deref().unwrap_or("");
let field_fqn = format!(".{}.{}", proto_fqn, field_name);
let bytes_repr = if field_type == Type::TYPE_BYTES {
ctx.bytes_repr(&field_fqn)
} else {
crate::BytesRepr::Vec
};
let map_value_bytes_repr = map_entry.map_or(crate::BytesRepr::Vec, |e| {
crate::impl_message::map_value_bytes_repr(
ctx,
map_entry_key_type(ctx, e, features),
map_entry_value_type(ctx, e, features),
proto_fqn,
field_name,
)
});
let bytes_type = || bytes_repr.type_path(resolver, ctx, nesting);
let string_repr = if field_type == Type::TYPE_STRING {
ctx.string_repr(&field_fqn)
} else {
crate::StringRepr::String
};
let string_type = || string_repr.type_path(resolver, ctx, nesting);
let map_string_repr = if is_map {
ctx.string_repr(&field_fqn)
} else {
crate::StringRepr::String
};
let map_repr = if is_map {
ctx.map_repr(&field_fqn)
} else {
crate::MapRepr::HashMap
};
let pointer_repr = ctx.pointer_repr(&field_fqn);
if pointer_repr != crate::PointerRepr::Inline
&& ctx
.config
.pointer_fields
.iter()
.rev()
.find(|(prefix, _)| crate::context::matches_proto_prefix(prefix, &field_fqn))
.is_some_and(|(p, r)| *p == field_fqn && *r == crate::PointerRepr::Inline)
{
return Err(CodeGenError::Other(format!(
"message field `{field_fqn}` is recursive and cannot be stored \
inline: it would make the generated struct unsized. Remove the \
exact `box_type_in(PointerRepr::Inline, &[\"{field_fqn}\"])` rule \
— the default keeps recursive fields boxed automatically."
)));
}
let repeated_repr = if is_repeated && !is_map {
ctx.repeated_repr(&field_fqn)
} else {
crate::RepeatedRepr::Vec
};
let mut inner_opt_type: Option<TokenStream> = None;
let rust_type = if let Some(entry) = map_entry {
map_rust_type_from_entry(
scope,
entry,
&map_value_bytes_repr,
&map_string_repr,
&map_repr,
resolver,
)?
} else if is_repeated {
let elem = if field_type == Type::TYPE_BYTES {
bytes_type()?
} else if field_type == Type::TYPE_STRING {
string_type()?
} else {
scalar_or_message_type_nested(ctx, field, current_package, nesting, features, resolver)?
};
repeated_repr.type_path(&elem, resolver, ctx, nesting)?
} else if field_type == Type::TYPE_MESSAGE || field_type == Type::TYPE_GROUP {
let inner = resolve_message_type(scope, field)?;
let mf = resolver.message_field_at(ctx, nesting);
pointer_repr.type_path(&mf, &inner)?
} else if is_optional {
let inner = if field_type == Type::TYPE_ENUM {
resolve_enum_type(scope, field, resolver)?
} else if field_type == Type::TYPE_BYTES {
bytes_type()?
} else if field_type == Type::TYPE_STRING {
string_type()?
} else {
scalar_rust_type(field_type, resolver, ctx, nesting)?
};
inner_opt_type = Some(inner.clone());
{
let opt = resolver.option_at(ctx, nesting);
quote! { #opt<#inner> }
}
} else if field_type == Type::TYPE_ENUM {
resolve_enum_type(scope, field, resolver)?
} else if field_type == Type::TYPE_BYTES {
bytes_type()?
} else if field_type == Type::TYPE_STRING {
string_type()?
} else {
scalar_rust_type(field_type, resolver, ctx, nesting)?
};
let self_fqn = format!(".{proto_fqn}");
let is_self_ref = field.type_name.as_deref() == Some(self_fqn.as_str()) && !is_map;
let struct_field_type = if is_self_ref {
if is_repeated {
repeated_repr.type_path("e! { Self }, resolver, ctx, nesting)?
} else {
let mf = resolver.message_field_at(ctx, nesting);
pointer_repr.type_path(&mf, "e! { Self })?
}
} else {
rust_type.clone()
};
let map_key_type = map_entry.and_then(|e| map_entry_key_type(ctx, e, features));
let map_value_type = map_entry.and_then(|e| map_entry_value_type(ctx, e, features));
let map_value_type_name = map_entry
.and_then(|e| e.field.iter().find(|f| f.number == Some(2)))
.and_then(|f| f.type_name.as_deref());
let is_wkt_wrapper = is_wkt_wrapper_type(field.type_name.as_deref());
let map_value_is_wkt_wrapper =
map_value_type == Some(Type::TYPE_MESSAGE) && is_wkt_wrapper_type(map_value_type_name);
let map_value_enum_closed = if map_value_type == Some(Type::TYPE_ENUM) {
map_entry
.and_then(|e| e.field.iter().find(|f| f.number == Some(2)))
.map(|val_fd| {
let val_features = crate::features::resolve_field(ctx, val_fd, features);
is_closed_enum(&val_features)
})
} else {
None
};
let map_string_is_custom = !map_string_repr.is_default();
let map_key_custom_string = map_key_type == Some(Type::TYPE_STRING) && map_string_is_custom;
let map_value_custom_string = map_value_type == Some(Type::TYPE_STRING) && map_string_is_custom;
let json_policy = !is_map
&& match (&bytes_repr, &string_repr) {
(crate::BytesRepr::Custom(path), _) | (_, crate::StringRepr::Custom(path)) => {
ctx.is_json_policy_type(path)
}
_ => false,
};
let map_string_policy = matches!(
&map_string_repr,
crate::StringRepr::Custom(path) if ctx.is_json_policy_type(path)
);
let map_key_json_policy = map_key_type == Some(Type::TYPE_STRING) && map_string_policy;
let map_value_json_policy = (map_value_type == Some(Type::TYPE_STRING) && map_string_policy)
|| matches!(
&map_value_bytes_repr,
crate::BytesRepr::Custom(path) if ctx.is_json_policy_type(path)
);
if map_key_json_policy && map_value_type == Some(Type::TYPE_ENUM) {
return Err(CodeGenError::JsonPolicyMapKey(field_fqn));
}
Ok(FieldInfo {
guarded: ctx.zeroizes_message(proto_fqn),
rust_type,
struct_field_type,
is_repeated,
is_custom_repeated: !repeated_repr.is_default(),
is_map,
is_optional,
is_required,
bytes_repr,
map_value_bytes_repr,
string_repr,
map_repr,
map_key_type,
map_value_type,
is_wkt_wrapper,
map_value_is_wkt_wrapper,
map_value_enum_closed,
map_key_custom_string,
map_value_custom_string,
json_policy,
map_key_json_policy,
map_value_json_policy,
inner_opt_type,
})
}
fn arbitrary_builder(info: &FieldInfo) -> Option<&'static str> {
enum Value {
Native,
String,
Bytes,
}
if info.is_map {
let value = if info.map_value_custom_string {
Value::String
} else if !info.map_value_bytes_repr.is_default() {
Value::Bytes
} else {
Value::Native
};
return match (info.map_key_custom_string, value) {
(false, Value::Native) => None,
(true, Value::Native) => Some("arbitrary_proto_string_map_key"),
(false, Value::String) => Some("arbitrary_proto_string_map_value"),
(true, Value::String) => Some("arbitrary_proto_string_map"),
(false, Value::Bytes) => Some("arbitrary_proto_bytes_map"),
(true, Value::Bytes) => Some("arbitrary_proto_string_bytes_map"),
};
}
let [singular, optional, repeated] = if !info.bytes_repr.is_default() {
[
"arbitrary_proto_bytes",
"arbitrary_proto_bytes_opt",
"arbitrary_proto_bytes_vec",
]
} else if !info.string_repr.is_default() {
[
"arbitrary_proto_string",
"arbitrary_proto_string_opt",
"arbitrary_proto_string_vec",
]
} else {
return None;
};
Some(if info.is_repeated {
repeated
} else if info.is_optional {
optional
} else {
singular
})
}
struct SetterInfo {
ident: Ident,
param_type: TokenStream,
use_into: bool,
wrap_optional: bool,
}
struct GeneratedField {
tokens: TokenStream,
json_default_helper: Option<TokenStream>,
ident: Ident,
setter: Option<SetterInfo>,
debug_redact: bool,
deprecated: bool,
}
fn generate_field(
scope: MessageScope<'_>,
msg: &DescriptorProto,
field: &crate::generated::descriptor::FieldDescriptorProto,
resolver: &crate::imports::ImportResolver,
) -> Result<Option<GeneratedField>, CodeGenError> {
let MessageScope {
ctx,
proto_fqn,
features,
..
} = scope;
let field_name = field
.name
.as_deref()
.ok_or(CodeGenError::MissingField("field.name"))?;
let field_number = field.number.unwrap_or(0);
if is_real_oneof_member(field) {
return Ok(None);
}
let info = classify_field(scope, msg, field, resolver)?;
let rust_name = ctx.field_ident(field_name, field_number);
let field_fqn = format!("{}.{}", proto_fqn, field_name);
let tag_line = format!("Field {field_number}: `{field_name}`");
let doc = crate::comments::doc_attrs_with_tag_resolved(
ctx.comment(&field_fqn),
&tag_line,
proto_fqn,
&ctx.type_map,
);
let serde_attr = if ctx.config.generate_json {
serde_field_attr(ctx, field, field_name, &info, features)
} else {
quote! {}
};
let custom_field_attrs =
CodeGenContext::matching_attributes(&ctx.config.field_attributes, &field_fqn)?;
let option_deprecated = is_deprecated(field);
let caller_deprecated = caller_deprecated_attr(ctx, &field_fqn);
let deprecated_attr =
(option_deprecated && !caller_deprecated).then(|| quote! { #[deprecated] });
let arbitrary_field_attr = ctx
.config
.generate_arbitrary
.then(|| {
(!ctx.zeroizes_message(proto_fqn))
.then(|| arbitrary_builder(&info))
.flatten()
})
.flatten()
.map(|builder| {
let builder = format_ident!("{builder}");
quote! {
#[cfg_attr(feature = "arbitrary", arbitrary(with = ::buffa::__private::#builder))]
}
});
let rust_type = &info.struct_field_type;
let rename_note = match ctx.field_rename_note(field_name, field_number) {
Some(note) => quote! { #[doc = ""] #[doc = #note] },
None => quote! {},
};
let caller_defaults = if ctx.config.generate_json {
caller_serde_default_conditions(&custom_field_attrs, &field_fqn)?
} else {
Vec::new()
};
let (json_default_attr, json_default_helper) = if ctx.config.generate_json
&& !caller_defaults.iter().any(Vec::is_empty)
{
let gates = ctx.config.feature_gates();
let fallback_condition = (!caller_defaults.is_empty()).then(|| {
let conditions = caller_defaults
.iter()
.map(|parts| match parts.as_slice() {
[condition] => quote! { #condition },
many => quote! { all(#(#many),*) },
})
.collect::<Vec<_>>();
let active = match conditions.as_slice() {
[condition] => condition.clone(),
many => quote! { any(#(#many),*) },
};
quote! { not(#active) }
});
let default_attr = |metadata: TokenStream| {
let metadata = match &fallback_condition {
Some(condition) => quote! { cfg_attr(#condition, #metadata) },
None => metadata,
};
crate::feature_gates::cfg_attr(metadata, gates.json)
};
match field_default_expr(scope, field)? {
Some(expression) => {
let helper = format_ident!("__buffa_default_field_{}", field_number.to_string());
let parent = ctx.config.prefixed_type_name(
msg.name
.as_deref()
.ok_or(CodeGenError::MissingField("message.name"))?,
);
let path = format!("{parent}::{helper}");
let attr = default_attr(quote! { serde(default = #path) });
let helper_condition = fallback_condition.as_ref().map(|condition| {
quote! { #[cfg(#condition)] }
});
let method = crate::feature_gates::cfg_block(
quote! {
#helper_condition
fn #helper() -> #rust_type { #expression }
},
gates.json,
);
(attr, Some(method))
}
None => (default_attr(quote! { serde(default) }), None),
}
} else {
(quote! {}, None)
};
let tokens = quote! {
#doc
#rename_note
#deprecated_attr
#serde_attr
#json_default_attr
#arbitrary_field_attr
#custom_field_attrs
pub #rust_name: #rust_type,
};
let target = info.inner_opt_type.as_ref().or_else(|| {
ctx.zeroizes_message(proto_fqn)
.then_some(&info.struct_field_type)
});
let setter = target.map(|inner| {
let field_type = crate::impl_message::effective_type(ctx, field, features);
let ident = format_ident!("with_{}", ctx.field_rust_name(field_name, field_number));
let use_into = info.is_repeated
|| info.is_map
|| matches!(
field_type,
Type::TYPE_STRING
| Type::TYPE_BYTES
| Type::TYPE_ENUM
| Type::TYPE_MESSAGE
| Type::TYPE_GROUP
);
let param_type = if use_into {
quote! {impl ::core::convert::Into<#inner>}
} else {
quote! {#inner}
};
SetterInfo {
ident,
param_type,
use_into,
wrap_optional: info.inner_opt_type.is_some(),
}
});
Ok(Some(GeneratedField {
tokens,
json_default_helper,
ident: rust_name,
setter,
debug_redact: is_debug_redacted(field) || ctx.zeroizes_message(proto_fqn),
deprecated: option_deprecated || caller_deprecated,
}))
}
fn caller_serde_default_conditions(
attributes: &TokenStream,
field: &str,
) -> Result<Vec<Vec<syn::Meta>>, CodeGenError> {
use syn::parse::Parser as _;
fn collect(
metadata: &syn::Meta,
conditions: &[syn::Meta],
defaults: &mut Vec<Vec<syn::Meta>>,
) -> syn::Result<()> {
let syn::Meta::List(list) = metadata else {
return Ok(());
};
if list.path.is_ident("serde") {
let options = list.parse_args_with(
syn::punctuated::Punctuated::<syn::Meta, syn::Token![,]>::parse_terminated,
)?;
if options
.iter()
.any(|option| option.path().is_ident("default"))
{
defaults.push(conditions.to_vec());
}
} else if list.path.is_ident("cfg_attr") {
let mut options = list
.parse_args_with(
syn::punctuated::Punctuated::<syn::Meta, syn::Token![,]>::parse_terminated,
)?
.into_iter();
if let Some(condition) = options.next() {
let mut conditions = conditions.to_vec();
conditions.push(condition);
for nested in options {
collect(&nested, &conditions, defaults)?;
}
}
}
Ok(())
}
let parse = || -> syn::Result<Vec<Vec<syn::Meta>>> {
let mut defaults = Vec::new();
for attribute in syn::Attribute::parse_outer.parse2(attributes.clone())? {
collect(&attribute.meta, &[], &mut defaults)?;
}
Ok(defaults)
};
parse().map_err(|error| CodeGenError::InvalidCustomAttribute {
path: field.to_owned(),
attribute: attributes.to_string(),
detail: error.to_string(),
})
}
pub(crate) fn is_map_field(
msg: &DescriptorProto,
field: &crate::generated::descriptor::FieldDescriptorProto,
) -> bool {
field.r#type.unwrap_or_default() == Type::TYPE_MESSAGE && find_map_entry(msg, field).is_some()
}
pub(crate) const DEBUG_REDACT_PLACEHOLDER: &str = "[REDACTED]";
pub(crate) fn is_debug_redacted(
field: &crate::generated::descriptor::FieldDescriptorProto,
) -> bool {
field
.options
.as_option()
.and_then(|o| o.debug_redact)
.unwrap_or(false)
}
pub(crate) fn field_is_deprecated(
ctx: &CodeGenContext,
field: &crate::generated::descriptor::FieldDescriptorProto,
field_fqn: &str,
) -> bool {
is_deprecated(field) || caller_deprecated_attr(ctx, field_fqn)
}
pub(crate) fn is_deprecated(field: &crate::generated::descriptor::FieldDescriptorProto) -> bool {
field
.options
.as_option()
.and_then(|o| o.deprecated)
.unwrap_or(false)
}
pub(crate) fn caller_deprecated_attr(ctx: &CodeGenContext, fqn: &str) -> bool {
rules_deprecate(&ctx.config.field_attributes, fqn)
}
fn rules_deprecate(rules: &[(String, String)], fqn: &str) -> bool {
if rules.is_empty() {
return false;
}
let fqn_dotted = format!(".{fqn}");
rules.iter().any(|(prefix, attr)| {
crate::context::matches_proto_prefix(prefix, &fqn_dotted) && is_deprecated_attr_str(attr)
})
}
pub(crate) fn is_deprecated_attr_str(attr: &str) -> bool {
let Ok(tokens) = syn::parse_str::<proc_macro2::TokenStream>(attr) else {
return false;
};
let mut iter = tokens.into_iter().peekable();
while let Some(tree) = iter.next() {
let proc_macro2::TokenTree::Punct(punct) = tree else {
continue;
};
if punct.as_char() != '#' {
continue;
}
if matches!(iter.peek(), Some(proc_macro2::TokenTree::Punct(bang)) if bang.as_char() == '!')
{
let _ = iter.next();
}
let Some(proc_macro2::TokenTree::Group(group)) = iter.next() else {
continue;
};
if group.delimiter() == proc_macro2::Delimiter::Bracket
&& names_deprecated(group.stream().into_iter())
{
return true;
}
}
false
}
fn names_deprecated(iter: impl Iterator<Item = proc_macro2::TokenTree>) -> bool {
use proc_macro2::{Delimiter, TokenTree};
let body: Vec<TokenTree> = iter.collect();
let mut it = body.iter();
let Some(TokenTree::Ident(id)) = it.next() else {
return false;
};
if id == "deprecated" {
return !matches!(it.next(), Some(TokenTree::Punct(p)) if p.as_char() == ':');
}
if id != "cfg_attr" {
return false;
}
let Some(TokenTree::Group(args)) = it.next() else {
return false;
};
if args.delimiter() != Delimiter::Parenthesis {
return false;
}
let args: Vec<TokenTree> = args.stream().into_iter().collect();
args.split(|t| matches!(t, TokenTree::Punct(p) if p.as_char() == ','))
.skip(1)
.any(|attr| names_deprecated(attr.iter().cloned()))
}
pub(crate) fn default_names_deprecated_value(
ctx: &CodeGenContext,
field: &crate::generated::descriptor::FieldDescriptorProto,
) -> bool {
if field.r#type.unwrap_or_default() != Type::TYPE_ENUM {
return false;
}
if field.label.unwrap_or_default() == Label::LABEL_REPEATED {
return false;
}
match (field.type_name.as_deref(), field.default_value.as_deref()) {
(Some(type_name), Some(default)) => ctx.enum_value_is_deprecated(type_name, default),
_ => false,
}
}
fn references_deprecated(ctx: &CodeGenContext, msg: &DescriptorProto, proto_fqn: &str) -> bool {
let oneof_rules = &ctx.config.oneof_struct_field_attributes;
msg.field.iter().any(|f| {
if crate::impl_message::is_real_oneof_member(f) {
return !oneof_rules.is_empty()
&& f.oneof_index
.and_then(|idx| msg.oneof_decl.get(usize::try_from(idx).ok()?))
.and_then(|oneof| oneof.name.as_deref())
.is_some_and(|name| {
rules_deprecate(oneof_rules, &format!("{proto_fqn}.{name}"))
});
}
let field_fqn = format!("{proto_fqn}.{}", f.name.as_deref().unwrap_or_default());
field_is_deprecated(ctx, f, &field_fqn) || default_names_deprecated_value(ctx, f)
})
}
pub(crate) fn deprecated_field_allow(
ctx: &CodeGenContext,
msg: &DescriptorProto,
proto_fqn: &str,
) -> TokenStream {
if references_deprecated(ctx, msg, proto_fqn) {
quote! { #[allow(deprecated)] }
} else {
TokenStream::new()
}
}
pub(crate) fn find_map_entry<'a>(
msg: &'a DescriptorProto,
field: &crate::generated::descriptor::FieldDescriptorProto,
) -> Option<&'a DescriptorProto> {
let type_name = field.type_name.as_deref()?;
let msg_name = msg.name.as_deref()?;
msg.nested_type.iter().find(|nested| {
nested
.options
.as_option()
.and_then(|o| o.map_entry)
.unwrap_or(false)
&& nested.name.as_deref().is_some_and(|entry_name| {
type_name
.strip_suffix(entry_name)
.and_then(|rest| rest.strip_suffix('.'))
.and_then(|parent| parent.strip_suffix(msg_name))
.is_some_and(|scope| scope.is_empty() || scope.ends_with('.'))
})
})
}
pub(crate) fn map_entry_key_type(
ctx: &CodeGenContext,
entry: &DescriptorProto,
features: &ResolvedFeatures,
) -> Option<Type> {
let key_field = entry.field.iter().find(|f| f.number == Some(1))?;
Some(crate::impl_message::effective_type_in_map_entry(
ctx, key_field, features,
))
}
pub(crate) fn map_entry_value_type(
ctx: &CodeGenContext,
entry: &DescriptorProto,
features: &ResolvedFeatures,
) -> Option<Type> {
let value_field = entry.field.iter().find(|f| f.number == Some(2))?;
Some(crate::impl_message::effective_type_in_map_entry(
ctx,
value_field,
features,
))
}
fn map_rust_type_from_entry(
scope: MessageScope<'_>,
entry: &DescriptorProto,
value_bytes_repr: &crate::BytesRepr,
string_repr: &crate::StringRepr,
map_repr: &crate::MapRepr,
resolver: &crate::imports::ImportResolver,
) -> Result<TokenStream, CodeGenError> {
let MessageScope {
ctx,
current_package,
features,
nesting,
..
} = scope;
let key_field = entry
.field
.iter()
.find(|f| f.number == Some(1))
.ok_or(CodeGenError::MissingField("map_entry.key"))?;
let value_field = entry
.field
.iter()
.find(|f| f.number == Some(2))
.ok_or(CodeGenError::MissingField("map_entry.value"))?;
let key_type = if crate::impl_message::effective_type_in_map_entry(ctx, key_field, features)
== Type::TYPE_STRING
&& !string_repr.is_default()
{
string_repr.type_path(resolver, ctx, nesting)?
} else {
scalar_or_message_type_nested(ctx, key_field, current_package, nesting, features, resolver)?
};
let value_effective =
crate::impl_message::effective_type_in_map_entry(ctx, value_field, features);
let value_type = if value_effective == Type::TYPE_BYTES && !value_bytes_repr.is_default() {
value_bytes_repr.type_path(resolver, ctx, nesting)?
} else if value_effective == Type::TYPE_STRING && !string_repr.is_default() {
string_repr.type_path(resolver, ctx, nesting)?
} else {
scalar_or_message_type_nested(
ctx,
value_field,
current_package,
nesting,
features,
resolver,
)?
};
map_repr.type_path(&key_type, &value_type, resolver, ctx, nesting)
}
pub(crate) fn scalar_or_message_type_nested(
ctx: &CodeGenContext,
field: &crate::generated::descriptor::FieldDescriptorProto,
current_package: &str,
nesting: usize,
features: &ResolvedFeatures,
resolver: &crate::imports::ImportResolver,
) -> Result<TokenStream, CodeGenError> {
let scope = MessageScope {
ctx,
current_package,
proto_fqn: "",
features,
nesting,
};
match crate::impl_message::effective_type(ctx, field, features) {
Type::TYPE_MESSAGE | Type::TYPE_GROUP => resolve_message_type(scope, field),
Type::TYPE_ENUM => resolve_enum_type(scope, field, resolver),
other => scalar_rust_type(other, resolver, ctx, nesting),
}
}
fn resolve_message_type(
scope: MessageScope<'_>,
field: &crate::generated::descriptor::FieldDescriptorProto,
) -> Result<TokenStream, CodeGenError> {
let type_name = field
.type_name
.as_deref()
.ok_or(CodeGenError::MissingField("field.type_name"))?;
let path_str = scope
.ctx
.rust_type_relative(type_name, scope.current_package, scope.nesting)
.ok_or_else(|| {
CodeGenError::Other(format!(
"message type '{type_name}' not found in descriptor set; \
ensure all imports are included with --include_imports"
))
})?;
let ty = rust_path_to_tokens(&path_str);
Ok(quote! { #ty })
}
fn resolve_enum_type(
scope: MessageScope<'_>,
field: &crate::generated::descriptor::FieldDescriptorProto,
resolver: &crate::imports::ImportResolver,
) -> Result<TokenStream, CodeGenError> {
let type_name = field
.type_name
.as_deref()
.ok_or(CodeGenError::MissingField("field.type_name"))?;
let path_str = scope
.ctx
.rust_type_relative(type_name, scope.current_package, scope.nesting)
.ok_or_else(|| {
CodeGenError::Other(format!(
"enum type '{type_name}' not found in descriptor set; \
ensure all imports are included with --include_imports"
))
})?;
let ty = rust_path_to_tokens(&path_str);
let field_features = crate::features::resolve_field(scope.ctx, field, scope.features);
if is_closed_enum(&field_features) {
Ok(quote! { #ty })
} else {
let ev = resolver.enum_value_at(scope.ctx, scope.nesting);
Ok(quote! { #ev<#ty> })
}
}
pub(crate) fn is_closed_enum(features: &ResolvedFeatures) -> bool {
features.enum_type == crate::features::EnumType::Closed
}
fn scalar_rust_type(
t: Type,
resolver: &crate::imports::ImportResolver,
ctx: &CodeGenContext,
nesting: usize,
) -> Result<TokenStream, CodeGenError> {
match t {
Type::TYPE_DOUBLE => Ok(quote! { f64 }),
Type::TYPE_FLOAT => Ok(quote! { f32 }),
Type::TYPE_INT64 | Type::TYPE_SINT64 | Type::TYPE_SFIXED64 => Ok(quote! { i64 }),
Type::TYPE_UINT64 | Type::TYPE_FIXED64 => Ok(quote! { u64 }),
Type::TYPE_INT32 | Type::TYPE_SINT32 | Type::TYPE_SFIXED32 => Ok(quote! { i32 }),
Type::TYPE_UINT32 | Type::TYPE_FIXED32 => Ok(quote! { u32 }),
Type::TYPE_BOOL => Ok(quote! { bool }),
Type::TYPE_STRING => Ok(resolver.string_at(ctx, nesting)),
Type::TYPE_BYTES => {
let vec = resolver.vec_at(ctx, nesting);
Ok(quote! { #vec<u8> })
}
Type::TYPE_GROUP | Type::TYPE_MESSAGE | Type::TYPE_ENUM => Err(CodeGenError::Other(
format!("scalar_rust_type called for non-scalar type {:?}", t),
)),
}
}
fn field_deser_modules(
field_type: Type,
info: &FieldInfo,
features: &ResolvedFeatures,
) -> (Option<&'static str>, Option<&'static str>) {
if info.json_policy {
let module = if info.is_repeated {
if !info.is_custom_repeated {
"::buffa::json_helpers::proto_seq"
} else {
"::buffa::json_helpers::proto_list"
}
} else {
match (field_type == Type::TYPE_BYTES, info.is_optional) {
(true, true) => "::buffa::json_helpers::opt_bytes_policy",
(true, false) => "::buffa::json_helpers::bytes_policy",
(false, true) => "::buffa::json_helpers::opt_string_policy",
(false, false) => "::buffa::json_helpers::string_policy",
}
};
return (Some(module), None);
}
if info.guarded && field_type == Type::TYPE_ENUM && !info.is_repeated {
let module = match (is_closed_enum(features), info.is_optional) {
(false, false) => "::buffa::json_helpers::guarded_enum::open",
(true, false) => "::buffa::json_helpers::guarded_enum::closed",
(false, true) => "::buffa::json_helpers::guarded_enum::optional_open",
(true, true) => "::buffa::json_helpers::guarded_enum::optional_closed",
};
return (Some(module), None);
}
let with_module = if info.is_map {
map_serde_module(info)
} else if info.is_repeated {
repeated_serde_module(field_type, info, features)
} else if info.is_optional {
optional_serde_module(field_type, features)
} else {
singular_serde_module(field_type, features)
};
let null_deser = if with_module.is_none() && (info.is_repeated || info.is_map) {
Some("::buffa::json_helpers::null_as_default")
} else {
None
};
(with_module, null_deser)
}
fn value_needs_proto_json(ty: Type) -> bool {
matches!(
ty,
Type::TYPE_INT32
| Type::TYPE_SINT32
| Type::TYPE_SFIXED32
| Type::TYPE_UINT32
| Type::TYPE_FIXED32
| Type::TYPE_INT64
| Type::TYPE_SINT64
| Type::TYPE_SFIXED64
| Type::TYPE_UINT64
| Type::TYPE_FIXED64
| Type::TYPE_FLOAT
| Type::TYPE_DOUBLE
| Type::TYPE_BYTES
)
}
fn map_serde_module(info: &FieldInfo) -> Option<&'static str> {
if info.map_key_json_policy {
return Some("::buffa::json_helpers::policy_str_key_map");
}
if info.guarded && info.map_value_enum_closed.is_none() {
return Some("::buffa::json_helpers::guarded_map");
}
if info.map_value_json_policy && !matches!(info.map_key_type, Some(Type::TYPE_BYTES)) {
return Some(if info.map_key_custom_string {
"::buffa::json_helpers::proto_str_key_map"
} else {
"::buffa::json_helpers::proto_map"
});
}
if matches!(info.map_key_type, Some(Type::TYPE_BYTES)) {
return Some(if matches!(info.map_value_type, Some(Type::TYPE_BYTES)) {
"::buffa::json_helpers::bytes_key_bytes_val_map"
} else {
"::buffa::json_helpers::bytes_key_map"
});
}
if let Some(closed) = info.map_value_enum_closed {
if info.guarded {
return Some(if closed {
"::buffa::json_helpers::guarded_enum::map_closed"
} else {
"::buffa::json_helpers::guarded_enum::map_open"
});
}
return Some(if closed {
"::buffa::json_helpers::map_closed_enum"
} else {
"::buffa::json_helpers::map_enum"
});
}
if info.map_value_is_wkt_wrapper {
return Some(if info.map_key_custom_string {
"::buffa::json_helpers::proto_str_key_map"
} else {
"::buffa::json_helpers::proto_map"
});
}
if matches!(info.map_value_type, Some(Type::TYPE_MESSAGE)) {
let is_string_key = matches!(info.map_key_type, Some(Type::TYPE_STRING));
return if is_string_key {
None
} else {
Some("::buffa::json_helpers::string_key_map")
};
}
let value_ty = info.map_value_type.unwrap_or(Type::TYPE_STRING);
let is_string_key = matches!(info.map_key_type, Some(Type::TYPE_STRING));
if value_needs_proto_json(value_ty) {
Some(if info.map_key_custom_string {
"::buffa::json_helpers::proto_str_key_map"
} else {
"::buffa::json_helpers::proto_map"
})
} else if is_string_key {
None
} else {
Some("::buffa::json_helpers::string_key_map")
}
}
fn repeated_serde_module(
field_type: Type,
info: &FieldInfo,
features: &ResolvedFeatures,
) -> Option<&'static str> {
let sequence = if !info.is_custom_repeated {
"::buffa::json_helpers::proto_seq"
} else {
"::buffa::json_helpers::proto_list"
};
match field_type {
Type::TYPE_ENUM => Some(if info.is_custom_repeated {
if is_closed_enum(features) {
"::buffa::json_helpers::enum_list::closed"
} else {
"::buffa::json_helpers::enum_list::open"
}
} else if is_closed_enum(features) {
"::buffa::json_helpers::repeated_closed_enum"
} else {
"::buffa::json_helpers::repeated_enum"
}),
Type::TYPE_MESSAGE | Type::TYPE_GROUP if info.is_wkt_wrapper => Some(sequence),
Type::TYPE_MESSAGE | Type::TYPE_GROUP => None,
ty if value_needs_proto_json(ty) => Some(sequence),
_ => None,
}
}
fn optional_serde_module(field_type: Type, features: &ResolvedFeatures) -> Option<&'static str> {
match field_type {
Type::TYPE_INT32 | Type::TYPE_SINT32 | Type::TYPE_SFIXED32 => {
Some("::buffa::json_helpers::opt_int32")
}
Type::TYPE_UINT32 | Type::TYPE_FIXED32 => Some("::buffa::json_helpers::opt_uint32"),
Type::TYPE_INT64 | Type::TYPE_SINT64 | Type::TYPE_SFIXED64 => {
Some("::buffa::json_helpers::opt_int64")
}
Type::TYPE_UINT64 | Type::TYPE_FIXED64 => Some("::buffa::json_helpers::opt_uint64"),
Type::TYPE_FLOAT => Some("::buffa::json_helpers::opt_float"),
Type::TYPE_DOUBLE => Some("::buffa::json_helpers::opt_double"),
Type::TYPE_BYTES => Some("::buffa::json_helpers::opt_bytes"),
Type::TYPE_ENUM => Some(if is_closed_enum(features) {
"::buffa::json_helpers::opt_closed_enum"
} else {
"::buffa::json_helpers::opt_enum"
}),
_ => None,
}
}
fn singular_serde_module(field_type: Type, features: &ResolvedFeatures) -> Option<&'static str> {
match field_type {
Type::TYPE_BOOL => Some("::buffa::json_helpers::proto_bool"),
Type::TYPE_STRING => Some("::buffa::json_helpers::proto_string"),
Type::TYPE_INT32 | Type::TYPE_SINT32 | Type::TYPE_SFIXED32 => {
Some("::buffa::json_helpers::int32")
}
Type::TYPE_UINT32 | Type::TYPE_FIXED32 => Some("::buffa::json_helpers::uint32"),
Type::TYPE_INT64 | Type::TYPE_SINT64 | Type::TYPE_SFIXED64 => {
Some("::buffa::json_helpers::int64")
}
Type::TYPE_UINT64 | Type::TYPE_FIXED64 => Some("::buffa::json_helpers::uint64"),
Type::TYPE_FLOAT => Some("::buffa::json_helpers::float"),
Type::TYPE_DOUBLE => Some("::buffa::json_helpers::double"),
Type::TYPE_BYTES => Some("::buffa::json_helpers::bytes"),
Type::TYPE_ENUM => Some(if is_closed_enum(features) {
"::buffa::json_helpers::closed_enum"
} else {
"::buffa::json_helpers::proto_enum"
}),
_ => None,
}
}
fn skip_serializing_predicate(
field_type: Type,
info: &FieldInfo,
features: &ResolvedFeatures,
) -> Option<&'static str> {
if info.is_required {
None
} else if info.is_map {
if info.map_repr.is_default() {
Some("::buffa::__private::HashMap::is_empty")
} else {
Some("::buffa::json_helpers::skip_if::is_empty_map")
}
} else if info.is_repeated {
Some("::buffa::json_helpers::skip_if::is_empty_vec")
} else if info.is_optional {
Some("::core::option::Option::is_none")
} else {
Some(singular_skip_predicate(field_type, features))
}
}
fn singular_skip_predicate(field_type: Type, features: &ResolvedFeatures) -> &'static str {
match field_type {
Type::TYPE_MESSAGE | Type::TYPE_GROUP => {
"::buffa::json_helpers::skip_if::is_unset_message_field"
}
Type::TYPE_ENUM => {
if is_closed_enum(features) {
"::buffa::json_helpers::skip_if::is_default_closed_enum"
} else {
"::buffa::json_helpers::skip_if::is_default_enum_value"
}
}
Type::TYPE_INT64 | Type::TYPE_SINT64 | Type::TYPE_SFIXED64 => {
"::buffa::json_helpers::skip_if::is_zero_i64"
}
Type::TYPE_UINT64 | Type::TYPE_FIXED64 => "::buffa::json_helpers::skip_if::is_zero_u64",
Type::TYPE_INT32 | Type::TYPE_SINT32 | Type::TYPE_SFIXED32 => {
"::buffa::json_helpers::skip_if::is_zero_i32"
}
Type::TYPE_UINT32 | Type::TYPE_FIXED32 => "::buffa::json_helpers::skip_if::is_zero_u32",
Type::TYPE_BOOL => "::buffa::json_helpers::skip_if::is_false",
Type::TYPE_FLOAT => "::buffa::json_helpers::skip_if::is_zero_f32",
Type::TYPE_DOUBLE => "::buffa::json_helpers::skip_if::is_zero_f64",
Type::TYPE_STRING => "::buffa::json_helpers::skip_if::is_empty_str",
Type::TYPE_BYTES => "::buffa::json_helpers::skip_if::is_empty_bytes",
}
}
fn serde_field_attr(
ctx: &CodeGenContext,
field: &crate::generated::descriptor::FieldDescriptorProto,
field_name: &str,
info: &FieldInfo,
features: &ResolvedFeatures,
) -> TokenStream {
let field_type = crate::impl_message::effective_type(ctx, field, features);
let field_features = crate::features::resolve_field(ctx, field, features);
let json_name = field.json_name.as_deref().unwrap_or(field_name);
let (with_module, null_deser) = field_deser_modules(field_type, info, &field_features);
let skip_if = skip_serializing_predicate(field_type, info, &field_features);
let needs_alias = json_name != field_name;
let alias_part = if needs_alias {
quote! { , alias = #field_name }
} else {
quote! {}
};
let with_part = if let Some(module) = with_module {
quote! { , with = #module }
} else {
quote! {}
};
let skip_part = if let Some(skip) = skip_if {
quote! { , skip_serializing_if = #skip }
} else {
quote! {}
};
let deser_part = if is_value_field(field, info.is_repeated, info.is_map) {
quote! { , deserialize_with = "::buffa::json_helpers::message_field_always_present" }
} else if let Some(deser) = null_deser {
quote! { , deserialize_with = #deser }
} else {
quote! {}
};
crate::feature_gates::cfg_attr(
quote! { serde(rename = #json_name #alias_part #with_part #skip_part #deser_part) },
ctx.config.feature_gates().json,
)
}
fn generate_custom_default(
ctx: &CodeGenContext,
msg: &DescriptorProto,
name_ident: &Ident,
current_package: &str,
proto_fqn: &str,
features: &ResolvedFeatures,
nesting: usize,
) -> Result<Option<TokenStream>, CodeGenError> {
let presence_explicit = features.field_presence == crate::features::FieldPresence::Explicit;
if !presence_explicit && !ctx.config.has_enum_type_overrides() {
return Ok(None);
}
let mut has_custom = false;
for field in &msg.field {
if is_real_oneof_member(field) {
continue;
}
let field_type = crate::impl_message::effective_type(ctx, field, features);
let is_optional = is_explicit_presence_scalar(field, field_type, features);
let is_repeated = field.label.unwrap_or_default() == Label::LABEL_REPEATED;
if is_optional
|| is_repeated
|| field_type == Type::TYPE_MESSAGE
|| field_type == Type::TYPE_GROUP
{
continue;
}
if (presence_explicit
&& field
.default_value
.as_deref()
.is_some_and(|s| !s.is_empty()))
|| (ctx.config.has_enum_type_overrides()
&& crate::defaults::open_enum_bare_default_value(
field,
ctx,
current_package,
&crate::features::resolve_field(ctx, field, features),
nesting,
)?
.is_some())
{
has_custom = true;
break;
}
}
if !has_custom {
return Ok(None);
}
let mut field_inits = Vec::new();
for field in &msg.field {
if is_real_oneof_member(field) {
continue;
}
let field_name = field
.name
.as_deref()
.ok_or(CodeGenError::MissingField("field.name"))?;
let field_ident = ctx.field_ident(field_name, field.number.unwrap_or(0));
let expression = field_default_expr(
MessageScope {
ctx,
current_package,
proto_fqn,
features,
nesting,
},
field,
)?
.unwrap_or_else(|| quote! { ::core::default::Default::default() });
field_inits.push(quote! { #field_ident: #expression, });
}
for (idx, oneof) in msg.oneof_decl.iter().enumerate() {
let oneof_name = oneof
.name
.as_deref()
.ok_or(CodeGenError::MissingField("oneof.name"))?;
let has_real = msg
.field
.iter()
.any(|f| is_real_oneof_member(f) && f.oneof_index == Some(idx as i32));
if has_real {
let ident = ctx.oneof_ident(oneof_name);
field_inits.push(quote! { #ident: ::core::default::Default::default(), });
}
}
let unknown_fields_init = if ctx.preserve_unknown_fields(proto_fqn) {
quote! { __buffa_unknown_fields: ::core::default::Default::default(), }
} else {
quote! {}
};
let deprecated_field_allow = deprecated_field_allow(ctx, msg, proto_fqn);
Ok(Some(quote! {
#deprecated_field_allow
impl ::core::default::Default for #name_ident {
fn default() -> Self {
Self {
#(#field_inits)*
#unknown_fields_init
}
}
}
}))
}
fn field_default_expr(
scope: MessageScope<'_>,
field: &crate::generated::descriptor::FieldDescriptorProto,
) -> Result<Option<TokenStream>, CodeGenError> {
let MessageScope {
ctx,
current_package,
proto_fqn,
features,
nesting,
} = scope;
let field_type = crate::impl_message::effective_type(ctx, field, features);
if is_explicit_presence_scalar(field, field_type, features)
|| field.label.unwrap_or_default() == Label::LABEL_REPEATED
|| matches!(field_type, Type::TYPE_MESSAGE | Type::TYPE_GROUP)
{
return Ok(None);
}
let field_name = field
.name
.as_deref()
.ok_or(CodeGenError::MissingField("field.name"))?;
let resolved = crate::features::resolve_field(ctx, field, features);
if let Some(expression) = parse_default_value(
field,
ctx,
current_package,
&resolved,
nesting,
crate::impl_message::field_string_repr(ctx, proto_fqn, field_name),
&crate::impl_message::field_bytes_repr(ctx, proto_fqn, field_name),
)? {
return Ok(Some(expression));
}
crate::defaults::open_enum_bare_default_value(field, ctx, current_package, &resolved, nesting)
}
pub(crate) use crate::idents::{make_field_ident, rust_path_to_tokens};