Files
sglang/rust/sglang-api-codegen/src/emit.rs
T

1082 lines
44 KiB
Rust

//! Pass 2: render each message's serde implementation from its
//! [`model::MessageModel`]. String-template emission; the output is checked
//! in and rustfmt'd, so it is reviewed like hand-written code.
//!
//! JSON contracts implemented here (see proto/sglang/json/v1/options.proto):
//! bare_list, tuple, one_or_many, tagged unions with passthrough, untagged
//! unions, per-field null/default/presence rules, raw_json passthrough, and
//! the IGNORE/DENY unknown-key policies with serde's own error texts.
use std::collections::HashMap;
use crate::model::{self, FieldKind, FieldModel, MessageKind, MessageModel, ScalarTy};
use prost_reflect::DescriptorPool;
pub fn emit_serde(descriptor_bytes: &[u8], package: &str) -> String {
let pool = DescriptorPool::decode(descriptor_bytes).expect("decode descriptor set");
let models = model::build_models(&pool, package);
let by_name: HashMap<&str, &MessageModel> =
models.iter().map(|m| (m.rust_name.as_str(), m)).collect();
let mut out = String::new();
out.push_str(
"// Generated by sglang-api-codegen from proto/sglang — DO NOT EDIT.\n\
// The sglang.json.v1 options in the schema are the JSON contract; edit the\n\
// .proto files and `cargo gen-api`.\n\n",
);
for m in &models {
match &m.kind {
MessageKind::Skip => {}
MessageKind::BareList { item } => emit_bare_list(&mut out, m, item),
MessageKind::Tuple { fields } => emit_tuple(&mut out, m, fields),
MessageKind::Transparent { field } => emit_transparent(&mut out, m, field),
MessageKind::OneOrMany {
oneof_mod,
one,
many,
} => emit_one_or_many(&mut out, m, oneof_mod, one, many, &by_name),
MessageKind::Untagged {
oneof_mod,
oneof_ident,
variants,
} => emit_untagged(&mut out, m, oneof_mod, oneof_ident, variants, &by_name),
MessageKind::TaggedUnion {
oneof_mod,
oneof_ident,
tag,
variants,
passthrough,
} => emit_tagged(
&mut out,
m,
oneof_mod,
oneof_ident,
tag,
variants,
passthrough.as_ref(),
),
MessageKind::Struct {
deny_unknown,
fields,
} => emit_struct(&mut out, m, *deny_unknown, fields),
}
}
out
}
fn item_rust_ty(kind: &FieldKind) -> String {
match kind {
FieldKind::RepeatedScalar { ty } => ty.rust().to_string(),
FieldKind::RepeatedMessage { rust_path } => rust_path.clone(),
other => panic!("bare_list item must be repeated, got {other:?}"),
}
}
fn emit_bare_list(out: &mut String, m: &MessageModel, item: &FieldModel) {
let name = &m.rust_name;
let field = &item.rust_ident;
let item_ty = item_rust_ty(&item.kind);
out.push_str(&format!(
r#"impl ::serde::Serialize for {name} {{
fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {{
serializer.collect_seq(self.{field}.iter())
}}
}}
impl<'de> ::serde::Deserialize<'de> for {name} {{
fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {{
Ok({name} {{
{field}: <::prost::alloc::vec::Vec<{item_ty}> as ::serde::Deserialize>::deserialize(deserializer)?,
}})
}}
}}
"#
));
}
fn emit_transparent(out: &mut String, m: &MessageModel, field: &FieldModel) {
let name = &m.rust_name;
let ident = &field.rust_ident;
let ty = match &field.kind {
FieldKind::OptScalar { ty, .. } => ty.rust().to_string(),
FieldKind::Message { rust_path, .. } => rust_path.clone(),
other => panic!(
"{name}: transparent field must be an optional scalar or a message, got {other:?}"
),
};
out.push_str(&format!(
r#"impl ::serde::Serialize for {name} {{
fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {{
self.{ident}.serialize(serializer)
}}
}}
impl<'de> ::serde::Deserialize<'de> for {name} {{
fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {{
Ok({name} {{
{ident}: <Option<{ty}> as ::serde::Deserialize>::deserialize(deserializer)?,
}})
}}
}}
"#
));
}
fn emit_tuple(out: &mut String, m: &MessageModel, fields: &[FieldModel]) {
let name = &m.rust_name;
let len = fields.len();
let mut ser_elems = String::new();
let mut de_elems = String::new();
for (i, f) in fields.iter().enumerate() {
let ident = &f.rust_ident;
ser_elems.push_str(&format!(
" ::serde::ser::SerializeSeq::serialize_element(&mut seq, &self.{ident})?;\n"
));
let ty = match &f.kind {
FieldKind::Scalar { ty, .. } => ty.rust().to_string(),
FieldKind::OptScalar { ty, .. } => format!("Option<{}>", ty.rust()),
other => panic!("tuple member kind {other:?} unsupported"),
};
de_elems.push_str(&format!(
" let {ident}: {ty} = seq
.next_element()?
.ok_or_else(|| ::serde::de::Error::invalid_length({i}, &\"a {len}-element tuple\"))?;\n"
));
}
let build: Vec<String> = fields.iter().map(|f| f.rust_ident.clone()).collect();
let build = build.join(", ");
out.push_str(&format!(
r#"impl ::serde::Serialize for {name} {{
fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {{
let mut seq = serializer.serialize_seq(Some({len}))?;
{ser_elems} ::serde::ser::SerializeSeq::end(seq)
}}
}}
impl<'de> ::serde::Deserialize<'de> for {name} {{
fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {{
struct V;
impl<'de> ::serde::de::Visitor<'de> for V {{
type Value = {name};
fn expecting(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {{
f.write_str("a {len}-element tuple")
}}
fn visit_seq<A: ::serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {{
{de_elems} Ok({name} {{ {build} }})
}}
}}
deserializer.deserialize_seq(V)
}}
}}
"#
));
}
fn emit_one_or_many(
out: &mut String,
m: &MessageModel,
oneof_mod: &str,
one: &model::VariantModel,
many: &model::VariantModel,
models: &HashMap<&str, &MessageModel>,
) {
let name = &m.rust_name;
let one_v = &one.rust_variant;
let many_v = &many.rust_variant;
let many_ty = match &many.kind {
FieldKind::Message { rust_path, .. } => rust_path.clone(),
other => panic!("{name}: many arm must be a list message, got {other:?}"),
};
// The scalar-shape visitors the `one` arm answers to.
let one_visits = match &one.kind {
FieldKind::Scalar {
ty: ScalarTy::Str, ..
}
| FieldKind::OptScalar {
ty: ScalarTy::Str, ..
} => format!(
r#" fn visit_str<E: ::serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {{
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(v.to_owned())) }})
}}
fn visit_string<E: ::serde::de::Error>(self, v: String) -> Result<Self::Value, E> {{
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(v)) }})
}}
"#
),
FieldKind::Scalar {
ty: ScalarTy::Bool, ..
}
| FieldKind::OptScalar {
ty: ScalarTy::Bool, ..
} => format!(
r#" fn visit_bool<E: ::serde::de::Error>(self, v: bool) -> Result<Self::Value, E> {{
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(v)) }})
}}
"#
),
FieldKind::Scalar {
ty: ScalarTy::I64, ..
}
| FieldKind::OptScalar {
ty: ScalarTy::I64, ..
} => format!(
r#" fn visit_i64<E: ::serde::de::Error>(self, v: i64) -> Result<Self::Value, E> {{
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(v)) }})
}}
fn visit_u64<E: ::serde::de::Error>(self, v: u64) -> Result<Self::Value, E> {{
let v = i64::try_from(v).map_err(|_| E::custom("integer out of range"))?;
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(v)) }})
}}
"#
),
// A message-typed `one` (SamplingParams, OptionalString wrappers):
// maps go to `one`; bare scalars for the Optional* wrappers arrive as
// visit_str/visit_i64 handled below in the wrapper-specific arm.
FieldKind::Message { rust_path, .. } => match rust_path.as_str() {
"OptionalString" => format!(
r#" fn visit_str<E: ::serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {{
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(OptionalString {{ value: Some(v.to_owned()) }})) }})
}}
fn visit_string<E: ::serde::de::Error>(self, v: String) -> Result<Self::Value, E> {{
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(OptionalString {{ value: Some(v) }})) }})
}}
"#
),
"OptionalInt64" => format!(
r#" fn visit_i64<E: ::serde::de::Error>(self, v: i64) -> Result<Self::Value, E> {{
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(OptionalInt64 {{ value: Some(v) }})) }})
}}
fn visit_u64<E: ::serde::de::Error>(self, v: u64) -> Result<Self::Value, E> {{
let v = i64::try_from(v).map_err(|_| E::custom("integer out of range"))?;
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(OptionalInt64 {{ value: Some(v) }})) }})
}}
"#
),
_ => format!(
r#" fn visit_map<A: ::serde::de::MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {{
let one = <{path} as ::serde::Deserialize>::deserialize(
::serde::de::value::MapAccessDeserializer::new(map),
)?;
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(one)) }})
}}
"#,
path = rust_path
),
},
other => panic!("{name}: unsupported one arm {other:?}"),
};
// Sequence handling. For a message-typed `one` whose JSON is ITSELF an
// array (TokenIds), the outer array is ambiguous: dispatch on the first
// element's shape (number => one flat id list, array/other => many).
let seq_visit = if let Some((one_ty, first_check)) = bare_scalar_list(&one.kind, models) {
format!(
r#" fn visit_seq<A: ::serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {{
let Some(first) = seq.next_element::<::serde_json::Value>()? else {{
// [] is one empty list (the untagged first-arm rule).
return Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}({one_ty}::default())) }});
}};
let is_number = {first_check};
let mut rest = vec![first];
while let Some(v) = seq.next_element::<::serde_json::Value>()? {{
rest.push(v);
}}
let reparse = ::serde_json::Value::Array(rest);
if is_number {{
let one: {one_ty} = ::serde_json::from_value(reparse)
.map_err(::serde::de::Error::custom)?;
Ok({name} {{ value: Some({oneof_mod}::Value::{one_v}(one)) }})
}} else {{
let many: {many_ty} = ::serde_json::from_value(reparse)
.map_err(::serde::de::Error::custom)?;
Ok({name} {{ value: Some({oneof_mod}::Value::{many_v}(many)) }})
}}
}}
"#
)
} else {
format!(
r#" fn visit_seq<A: ::serde::de::SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> {{
let many = <{many_ty} as ::serde::Deserialize>::deserialize(
::serde::de::value::SeqAccessDeserializer::new(seq),
)?;
Ok({name} {{ value: Some({oneof_mod}::Value::{many_v}(many)) }})
}}
"#
)
};
let companion = if matches!(&one.kind, FieldKind::Message { rust_path, .. } if rust_path == "SamplingParams")
{
format!(
"impl {name} {{\n /// Protobuf arrival: recurse the absent-defaults rule into the params.\n pub fn apply_absent_defaults(&mut self) {{\n match self.value.as_mut() {{\n Some({oneof_mod}::Value::{one_v}(p)) => p.apply_absent_defaults(),\n Some({oneof_mod}::Value::{many_v}(l)) => {{\n for p in &mut l.items {{\n p.apply_absent_defaults();\n }}\n }}\n None => {{}}\n }}\n }}\n}}\n\n"
)
} else {
String::new()
};
out.push_str(&companion);
let expecting = format!("a value or an array of values for {name}");
out.push_str(&format!(
r#"impl ::serde::Serialize for {name} {{
fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {{
match &self.value {{
Some({oneof_mod}::Value::{one_v}(v)) => v.serialize(serializer),
Some({oneof_mod}::Value::{many_v}(v)) => v.serialize(serializer),
None => serializer.serialize_none(),
}}
}}
}}
impl<'de> ::serde::Deserialize<'de> for {name} {{
fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {{
struct V;
impl<'de> ::serde::de::Visitor<'de> for V {{
type Value = {name};
fn expecting(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {{
f.write_str({expecting:?})
}}
{one_visits}{seq_visit} }}
deserializer.deserialize_any(V)
}}
}}
"#
));
}
/// The JSON value shapes a field or message can take; the untagged dispatch
/// keys on these.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum JsonShape {
Str,
Int,
Float,
Bool,
Map,
Seq,
Null,
}
fn scalar_shapes(ty: &ScalarTy) -> Vec<JsonShape> {
match ty {
ScalarTy::Str => vec![JsonShape::Str],
ScalarTy::I32 | ScalarTy::I64 | ScalarTy::U32 | ScalarTy::U64 => vec![JsonShape::Int],
ScalarTy::F64 => vec![JsonShape::Int, JsonShape::Float],
ScalarTy::Bool => vec![JsonShape::Bool],
}
}
fn kind_shapes(kind: &FieldKind, models: &HashMap<&str, &MessageModel>) -> Vec<JsonShape> {
match kind {
FieldKind::Scalar { ty, .. } | FieldKind::OptScalar { ty, .. } => scalar_shapes(ty),
FieldKind::Message { rust_path, .. } => message_shapes(rust_path, models),
FieldKind::RepeatedScalar { .. }
| FieldKind::RepeatedMessage { .. }
| FieldKind::RepeatedRawJson => vec![JsonShape::Seq],
FieldKind::Map { .. } => vec![JsonShape::Map],
FieldKind::RawJson { .. } => vec![
JsonShape::Str,
JsonShape::Int,
JsonShape::Float,
JsonShape::Bool,
JsonShape::Map,
JsonShape::Seq,
JsonShape::Null,
],
}
}
fn message_shapes(name: &str, models: &HashMap<&str, &MessageModel>) -> Vec<JsonShape> {
let m = models
.get(name)
.unwrap_or_else(|| panic!("unknown message {name}"));
match &m.kind {
MessageKind::Struct { .. } | MessageKind::TaggedUnion { .. } => vec![JsonShape::Map],
MessageKind::Tuple { .. } | MessageKind::BareList { .. } => vec![JsonShape::Seq],
MessageKind::Transparent { field } => {
let mut s = kind_shapes(&field.kind, models);
s.push(JsonShape::Null);
s
}
MessageKind::Untagged { variants, .. } => {
let mut s = Vec::new();
for v in variants {
for shape in kind_shapes(&v.kind, models) {
if !s.contains(&shape) {
s.push(shape);
}
}
}
s
}
MessageKind::OneOrMany { one, .. } => {
let mut s = kind_shapes(&one.kind, models);
if !s.contains(&JsonShape::Seq) {
s.push(JsonShape::Seq);
}
s
}
MessageKind::Skip => panic!("{name}: a gRPC-only message has no JSON shape"),
}
}
/// For a bare-list message: the shapes of one ELEMENT.
fn element_shapes(name: &str, models: &HashMap<&str, &MessageModel>) -> Vec<JsonShape> {
let m = models
.get(name)
.unwrap_or_else(|| panic!("unknown message {name}"));
match &m.kind {
MessageKind::BareList { item } => match &item.kind {
FieldKind::RepeatedScalar { ty } => scalar_shapes(ty),
FieldKind::RepeatedMessage { rust_path } => message_shapes(rust_path, models),
other => panic!("{name}: bare_list item must be repeated, got {other:?}"),
},
other => panic!("{name}: not a bare list ({other:?})"),
}
}
/// A `one` arm that is a bare list of scalars: its Rust type and the
/// `serde_json::Value` test that recognizes one of its elements.
fn bare_scalar_list(
kind: &FieldKind,
models: &HashMap<&str, &MessageModel>,
) -> Option<(String, &'static str)> {
let FieldKind::Message { rust_path, .. } = kind else {
return None;
};
let m = models.get(rust_path.as_str())?;
let MessageKind::BareList { item } = &m.kind else {
return None;
};
let FieldKind::RepeatedScalar { ty } = &item.kind else {
return None;
};
let check = match ty {
ScalarTy::Str => "first.is_string()",
ScalarTy::Bool => "first.is_boolean()",
_ => "first.is_number()",
};
Some((rust_path.clone(), check))
}
/// A message-typed arm built from a visited scalar `v`: the message's own
/// `Deserialize` runs over a value deserializer, so its rules (unknown-key
/// policy, nested unions) apply unchanged.
fn via_value_deserializer(ty: &str, de: &str) -> String {
format!("<{ty} as ::serde::Deserialize>::deserialize(::serde::de::value::{de}::<E>::new(v))?")
}
fn emit_untagged(
out: &mut String,
m: &MessageModel,
oneof_mod: &str,
oneof_ident: &str,
variants: &[model::VariantModel],
models: &HashMap<&str, &MessageModel>,
) {
let name = &m.rust_name;
let wrap = |var: &str, expr: &str| {
format!("Ok({name} {{ value: Some({oneof_mod}::{oneof_ident}::{var}({expr})) }})")
};
let mut ser_arms = String::new();
// shape -> the arms claiming it, in declaration order.
let mut claims: Vec<(JsonShape, Vec<&model::VariantModel>)> = Vec::new();
for v in variants {
ser_arms.push_str(&format!(
" Some({oneof_mod}::{oneof_ident}::{}(v)) => v.serialize(serializer),\n",
v.rust_variant
));
for shape in kind_shapes(&v.kind, models) {
match claims.iter_mut().find(|(s, _)| *s == shape) {
Some((_, arms)) => arms.push(v),
None => claims.push((shape, vec![v])),
}
}
}
let mut visits = String::new();
for (shape, arms) in &claims {
if *shape != JsonShape::Seq && arms.len() > 1 {
panic!(
"{name}: untagged arms {:?} all accept a JSON {shape:?}; the value's shape cannot pick one",
arms.iter().map(|a| &a.json_name).collect::<Vec<_>>()
);
}
let arm = arms[0];
let var = &arm.rust_variant;
// A scalar arm takes the value as-is; a message arm runs the message's
// own deserializer over it.
let scalar_arm = matches!(
arm.kind,
FieldKind::Scalar { .. } | FieldKind::OptScalar { .. }
);
let msg_ty = match &arm.kind {
FieldKind::Message { rust_path, .. } => Some(rust_path.as_str()),
_ => None,
};
let build = |de: &str, direct: &str| -> String {
if scalar_arm {
wrap(var, direct)
} else {
wrap(
var,
&via_value_deserializer(msg_ty.expect("message arm"), de),
)
}
};
let unit = |var: &str| {
wrap(
var,
&format!(
"<{} as ::serde::Deserialize>::deserialize(::serde::de::value::UnitDeserializer::<E>::new())?",
msg_ty.expect("null arm is a message")
),
)
};
match shape {
JsonShape::Str => visits.push_str(&format!(
r#" fn visit_str<E: ::serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {{
{}
}}
fn visit_string<E: ::serde::de::Error>(self, v: String) -> Result<Self::Value, E> {{
{}
}}
"#,
build("StrDeserializer", "v.to_owned()"),
build("StringDeserializer", "v")
)),
JsonShape::Int => visits.push_str(&format!(
r#" fn visit_i64<E: ::serde::de::Error>(self, v: i64) -> Result<Self::Value, E> {{
{}
}}
fn visit_u64<E: ::serde::de::Error>(self, v: u64) -> Result<Self::Value, E> {{
let v = i64::try_from(v).map_err(|_| E::custom("integer out of range"))?;
{}
}}
"#,
build("I64Deserializer", "v"),
build("I64Deserializer", "v")
)),
JsonShape::Float => visits.push_str(&format!(
r#" fn visit_f64<E: ::serde::de::Error>(self, v: f64) -> Result<Self::Value, E> {{
{}
}}
"#,
build("F64Deserializer", "v")
)),
JsonShape::Bool => visits.push_str(&format!(
r#" fn visit_bool<E: ::serde::de::Error>(self, v: bool) -> Result<Self::Value, E> {{
{}
}}
"#,
build("BoolDeserializer", "v")
)),
JsonShape::Null => visits.push_str(&format!(
r#" fn visit_unit<E: ::serde::de::Error>(self) -> Result<Self::Value, E> {{
{}
}}
fn visit_none<E: ::serde::de::Error>(self) -> Result<Self::Value, E> {{
{}
}}
"#,
unit(var),
unit(var)
)),
JsonShape::Map => visits.push_str(&format!(
r#" fn visit_map<A: ::serde::de::MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {{
let v = <{ty} as ::serde::Deserialize>::deserialize(
::serde::de::value::MapAccessDeserializer::new(map),
)?;
{}
}}
"#,
wrap(var, "v"),
ty = msg_ty.expect("map arm is a message")
)),
JsonShape::Seq => {
if arms.len() == 1 {
visits.push_str(&format!(
r#" fn visit_seq<A: ::serde::de::SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> {{
let v = <{ty} as ::serde::Deserialize>::deserialize(
::serde::de::value::SeqAccessDeserializer::new(seq),
)?;
{}
}}
"#,
wrap(var, "v"),
ty = msg_ty.expect("seq arm is a message")
));
} else {
// Two array-shaped arms: the one whose ELEMENTS are arrays
// is the nested form; the first element decides, and `[]`
// is the flat form.
assert_eq!(arms.len(), 2, "{name}: more than two array-shaped untagged arms");
let elem_is_seq = |a: &model::VariantModel| match &a.kind {
FieldKind::Message { rust_path, .. } => {
element_shapes(rust_path, models).contains(&JsonShape::Seq)
}
_ => false,
};
let (nested, flat) = match (elem_is_seq(arms[0]), elem_is_seq(arms[1])) {
(true, false) => (arms[0], arms[1]),
(false, true) => (arms[1], arms[0]),
_ => panic!(
"{name}: array-shaped arms {} and {} cannot be told apart by their first element",
arms[0].json_name, arms[1].json_name
),
};
let ty_of = |a: &model::VariantModel| match &a.kind {
FieldKind::Message { rust_path, .. } => rust_path.clone(),
_ => unreachable!(),
};
visits.push_str(&format!(
r#" fn visit_seq<A: ::serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {{
let mut items: Vec<::serde_json::Value> = Vec::new();
while let Some(v) = seq.next_element::<::serde_json::Value>()? {{
items.push(v);
}}
let nested = items.first().is_some_and(|f| f.is_array());
let reparse = ::serde_json::Value::Array(items);
if nested {{
let v: {nested_ty} = ::serde_json::from_value(reparse)
.map_err(::serde::de::Error::custom)?;
{nested_ok}
}} else {{
let v: {flat_ty} = ::serde_json::from_value(reparse)
.map_err(::serde::de::Error::custom)?;
{flat_ok}
}}
}}
"#,
nested_ty = ty_of(nested),
flat_ty = ty_of(flat),
nested_ok = wrap(&nested.rust_variant, "v"),
flat_ok = wrap(&flat.rust_variant, "v"),
));
}
}
}
}
out.push_str(&format!(
r#"impl ::serde::Serialize for {name} {{
fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {{
match &self.value {{
{ser_arms} None => serializer.serialize_none(),
}}
}}
}}
impl<'de> ::serde::Deserialize<'de> for {name} {{
fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {{
struct V;
impl<'de> ::serde::de::Visitor<'de> for V {{
type Value = {name};
fn expecting(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {{
f.write_str("one of the {name} shapes")
}}
{visits} }}
deserializer.deserialize_any(V)
}}
}}
"#
));
}
/// Serialize one struct/payload field into `map` (a SerializeMap), honoring
/// the field's presence/null rules. `always_emit_null` = tagged-union payload
/// semantics: optional members emit null instead of being skipped.
fn ser_field(f: &FieldModel, receiver: &str, always_emit_null: bool) -> String {
let key = &f.json_name;
let ident = &f.rust_ident;
let get = format!("{receiver}{ident}");
match &f.kind {
FieldKind::Scalar { .. } => format!(
" ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &{get})?;\n"
),
FieldKind::OptScalar {
emit_null,
null_is_none_default,
..
} => {
// null_is_none: None means "explicit null", distinct from absent
// (the default), so it must serialize as null to round-trip.
if *emit_null || always_emit_null || null_is_none_default.is_some() {
format!(
" ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &{get})?;\n"
)
} else {
format!(
" if let Some(v) = &{get} {{\n ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, v)?;\n }}\n"
)
}
}
FieldKind::Message { emit_null, .. } => {
if *emit_null || always_emit_null {
format!(
" ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &{get})?;\n"
)
} else {
format!(
" if let Some(v) = &{get} {{\n ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, v)?;\n }}\n"
)
}
}
FieldKind::RepeatedScalar { .. } | FieldKind::RepeatedMessage { .. } => format!(
" if !{get}.is_empty() {{\n ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &{get})?;\n }}\n"
),
FieldKind::RepeatedRawJson => format!(
" if !{get}.is_empty() {{\n let rows: Vec<::serde_json::Value> = {get}\n .iter()\n .map(|s| ::serde_json::from_str(s).unwrap_or(::serde_json::Value::Null))\n .collect();\n ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &rows)?;\n }}\n"
),
FieldKind::Map { .. } => format!(
" if !{get}.is_empty() {{\n ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &{get})?;\n }}\n"
),
FieldKind::RawJson { emit_null } => {
let body = format!(
"::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &::serde_json::from_str::<::serde_json::Value>(v).unwrap_or(::serde_json::Value::Null))?;"
);
if *emit_null || always_emit_null {
format!(
" match &{get} {{\n Some(v) => {{ {body} }}\n None => {{ ::serde::ser::SerializeMap::serialize_entry(&mut map, {key:?}, &::serde_json::Value::Null)?; }}\n }}\n"
)
} else {
format!(" if let Some(v) = &{get} {{\n {body}\n }}\n")
}
}
}
}
/// The visitor-arm statements deserializing one field's value into its local
/// `Option<...>` slot named `f_<ident>` (positioned errors preserved via
/// `map.next_value`).
fn de_field_arm(f: &FieldModel) -> String {
let key = &f.json_name;
let ident = &f.rust_ident;
let slot = format!("f_{}", ident.trim_start_matches("r#"));
let dup = format!(
" if {slot}.is_some() {{\n return Err(::serde::de::Error::duplicate_field({key:?}));\n }}\n"
);
let read = match &f.kind {
FieldKind::Scalar { ty, null_default } => match null_default {
// Explicit null resets to the default (Python __post_init__
// parity); the value type still errors on shape mismatch.
Some(default) => format!(
" {slot} = Some(map.next_value::<Option<{ty}>>()?.unwrap_or_else(|| {default}));\n",
ty = ty.rust(),
default = default.rust()
),
None => format!(
" {slot} = Some(map.next_value::<{ty}>()?);\n",
ty = ty.rust()
),
},
FieldKind::OptScalar {
ty, null_default, ..
} => match null_default {
// null_resets_default: explicit null is the schema default.
Some(default) => format!(
" {slot} = Some(Some(map.next_value::<Option<{ty}>>()?.unwrap_or_else(|| {default})));\n",
ty = ty.rust(),
default = default.rust()
),
None => format!(
" {slot} = Some(map.next_value::<Option<{ty}>>()?);\n",
ty = ty.rust()
),
},
FieldKind::Message { rust_path, .. } => format!(
" {slot} = Some(map.next_value::<Option<{rust_path}>>()?);\n"
),
FieldKind::RepeatedScalar { ty } => format!(
" {slot} = Some(map.next_value::<Option<Vec<{ty}>>>()?.unwrap_or_default());\n",
ty = ty.rust()
),
FieldKind::RepeatedMessage { rust_path } => format!(
" {slot} = Some(map.next_value::<Option<Vec<{rust_path}>>>()?.unwrap_or_default());\n"
),
FieldKind::RepeatedRawJson => format!(
" {slot} = Some(map.next_value::<Option<Vec<::serde_json::Value>>>()?.unwrap_or_default().into_iter().map(|v| v.to_string()).collect());\n"
),
FieldKind::Map { value } => format!(
" {slot} = Some(map.next_value::<Option<::std::collections::HashMap<String, {ty}>>>()?.unwrap_or_default());\n",
ty = value.rust()
),
FieldKind::RawJson { .. } => format!(
" {slot} = Some(map.next_value::<Option<::serde_json::Value>>()?.map(|v| v.to_string()));\n"
),
};
format!(" {key:?} => {{\n{dup}{read} }}\n")
}
/// The absent-key fallback expression building the struct field from its
/// visitor slot.
fn de_field_finish(f: &FieldModel) -> String {
let ident = &f.rust_ident;
let slot = format!("f_{}", ident.trim_start_matches("r#"));
let expr = match &f.kind {
FieldKind::Scalar { null_default, .. } => match null_default {
Some(default) => format!(
"{slot}.unwrap_or_else(|| {default})",
default = default.rust()
),
None => format!("{slot}.unwrap_or_default()"),
},
FieldKind::OptScalar {
null_is_none_default,
null_default,
..
} => match (null_is_none_default, null_default) {
// Absent => the default; explicit null => None (already in the
// slot as Some(None)).
(Some(default), _) | (_, Some(default)) => format!(
"{slot}.unwrap_or_else(|| Some({default}))",
default = default.rust()
),
(None, None) => format!("{slot}.flatten()"),
},
FieldKind::Message { .. } => format!("{slot}.flatten()"),
FieldKind::RepeatedScalar { .. }
| FieldKind::RepeatedMessage { .. }
| FieldKind::RepeatedRawJson
| FieldKind::Map { .. } => format!("{slot}.unwrap_or_default()"),
FieldKind::RawJson { .. } => format!("{slot}.flatten()"),
};
format!(" {ident}: {expr},\n")
}
/// Companion impl for a struct message: `*_or_default` accessors for every
/// schema-defaulted field (protobuf arrival has presence but no baked
/// defaults), and `apply_absent_defaults` filling every unset defaulted slot —
/// the gRPC entry's "proto unset = JSON absent" rule, recursing into
/// defaulted children.
fn emit_struct_companion(out: &mut String, m: &MessageModel, fields: &[FieldModel]) {
let name = &m.rust_name;
let mut accessors = String::new();
let mut fills = String::new();
for f in fields {
let ident = &f.rust_ident;
let plain = ident.trim_start_matches("r#");
match &f.kind {
FieldKind::OptScalar {
ty,
null_default: Some(default),
..
}
| FieldKind::OptScalar {
ty,
null_is_none_default: Some(default),
..
} => {
let ty = ty.rust();
let default = default.rust();
accessors.push_str(&format!(
" /// The schema default when unset (protobuf arrival).\n pub fn {plain}_or_default(&self) -> {ty} {{\n self.{ident}.clone().unwrap_or_else(|| {default})\n }}\n"
));
fills.push_str(&format!(
" if self.{ident}.is_none() {{\n self.{ident} = Some({default});\n }}\n"
));
}
FieldKind::Message { rust_path, .. }
if matches!(rust_path.as_str(), "SamplingParamsOrList") =>
{
fills.push_str(&format!(
" if let Some(v) = self.{ident}.as_mut() {{\n v.apply_absent_defaults();\n }}\n"
));
}
_ => {}
}
}
if accessors.is_empty() && fills.is_empty() {
return;
}
out.push_str(&format!(
"impl {name} {{\n{accessors} /// Protobuf arrival: unset defaulted fields become their schema\n /// defaults (JSON arrival already baked them at deserialization).\n pub fn apply_absent_defaults(&mut self) {{\n{fills} }}\n}}\n\n"
));
}
fn emit_struct(out: &mut String, m: &MessageModel, deny_unknown: bool, fields: &[FieldModel]) {
emit_struct_companion(out, m, fields);
let name = &m.rust_name;
let map_binding = if fields.is_empty() { "map" } else { "mut map" };
let mut ser_body = String::new();
for f in fields {
ser_body.push_str(&ser_field(f, "self.", false));
}
let mut arms = String::new();
let mut slots = String::new();
let mut finish = String::new();
let mut field_names = String::new();
for f in fields {
arms.push_str(&de_field_arm(f));
let slot = format!("f_{}", f.rust_ident.trim_start_matches("r#"));
slots.push_str(&format!(" let mut {slot} = None;\n"));
finish.push_str(&de_field_finish(f));
field_names.push_str(&format!("{:?}, ", f.json_name));
}
let unknown_arm = if deny_unknown {
" other => {\n return Err(::serde::de::Error::unknown_field(other, FIELDS));\n }\n"
.to_string()
} else {
" _ => {\n map.next_value::<::serde::de::IgnoredAny>()?;\n }\n"
.to_string()
};
let fields_const = if deny_unknown {
format!(" const FIELDS: &[&str] = &[{field_names}];\n")
} else {
String::new()
};
out.push_str(&format!(
r#"impl ::serde::Serialize for {name} {{
fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {{
let {map_binding} = serializer.serialize_map(None)?;
{ser_body} ::serde::ser::SerializeMap::end(map)
}}
}}
impl<'de> ::serde::Deserialize<'de> for {name} {{
fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {{
{fields_const} struct V;
impl<'de> ::serde::de::Visitor<'de> for V {{
type Value = {name};
fn expecting(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {{
f.write_str("struct {name}")
}}
fn visit_map<A: ::serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {{
{slots} while let Some(key) = map.next_key::<::std::borrow::Cow<'_, str>>()? {{
match key.as_ref() {{
{arms}{unknown_arm} }}
}}
Ok({name} {{
{finish} }})
}}
}}
deserializer.deserialize_map(V)
}}
}}
"#
));
}
fn emit_tagged(
out: &mut String,
m: &MessageModel,
oneof_mod: &str,
oneof_ident: &str,
tag: &str,
variants: &[model::VariantModel],
passthrough: Option<&model::VariantModel>,
) {
let name = &m.rust_name;
// Serialize: {tag: variant_name, ...payload fields inlined (optional
// members as explicit nulls, matching serde's tagged-enum output)}.
let mut ser_arms = String::new();
for v in variants {
let var = &v.rust_variant;
let tag_value = &v.json_name;
let mut payload = String::new();
for f in &v.payload_fields {
payload.push_str(&ser_field(f, "v.", true));
}
ser_arms.push_str(&format!(
r#" Some({oneof_mod}::{oneof_ident}::{var}(v)) => {{
let mut map = serializer.serialize_map(None)?;
::serde::ser::SerializeMap::serialize_entry(&mut map, {tag:?}, {tag_value:?})?;
{payload} ::serde::ser::SerializeMap::end(map)
}}
"#
));
}
if let Some(p) = passthrough {
let var = &p.rust_variant;
ser_arms.push_str(&format!(
r#" Some({oneof_mod}::{oneof_ident}::{var}(v)) => {{
::serde::Serialize::serialize(&::serde_json::from_str::<::serde_json::Value>(v).unwrap_or(::serde_json::Value::Null), serializer)
}}
"#
));
}
// Deserialize: buffer the map (the tag can appear anywhere; a known tag
// whose payload fails to parse falls back to the passthrough arm, the
// hand-written FinishReason contract).
let mut de_arms = String::new();
for v in variants {
let var = &v.rust_variant;
let tag_value = &v.json_name;
let mut fields = String::new();
for f in &v.payload_fields {
let ident = &f.rust_ident;
let key = &f.json_name;
let read = match &f.kind {
FieldKind::OptScalar { ty, .. } => format!(
"match raw.get({key:?}) {{ None | Some(::serde_json::Value::Null) => None, Some(v) => match ::serde_json::from_value::<{ty}>(v.clone()) {{ Ok(v) => Some(v), Err(_) => return fallback(raw) }} }}",
ty = ty.rust()
),
FieldKind::Message { rust_path, .. } => format!(
"match raw.get({key:?}) {{ None | Some(::serde_json::Value::Null) => None, Some(v) => match ::serde_json::from_value::<{rust_path}>(v.clone()) {{ Ok(v) => Some(v), Err(_) => return fallback(raw) }} }}"
),
other => panic!("{name}: tagged payload field kind {other:?} unsupported"),
};
fields.push_str(&format!(" {ident}: {read},\n"));
}
de_arms.push_str(&format!(
r#" Some({tag_value:?}) => {{
let payload = {payload_ty} {{
{fields} }};
Ok({name} {{ kind: Some({oneof_mod}::{oneof_ident}::{var}(payload.into())) }})
}}
"#,
payload_ty = match &v.kind {
FieldKind::Message { rust_path, .. } => rust_path.clone(),
other => panic!("{name}: tagged variant must be message-typed, got {other:?}"),
}
));
}
let fallback = match passthrough {
Some(p) => {
let var = &p.rust_variant;
format!(
r#" fn fallback<E: ::serde::de::Error>(raw: ::serde_json::Map<String, ::serde_json::Value>) -> Result<{name}, E> {{
Ok({name} {{ kind: Some({oneof_mod}::{oneof_ident}::{var}(::serde_json::Value::Object(raw).to_string())) }})
}}
"#
)
}
None => format!(
r#" fn fallback<E: ::serde::de::Error>(_raw: ::serde_json::Map<String, ::serde_json::Value>) -> Result<{name}, E> {{
Err(E::custom("unknown {tag} for {name}"))
}}
"#
),
};
out.push_str(&format!(
r#"impl ::serde::Serialize for {name} {{
fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {{
match &self.kind {{
{ser_arms} None => serializer.serialize_none(),
}}
}}
}}
impl<'de> ::serde::Deserialize<'de> for {name} {{
fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {{
{fallback} let raw = ::serde_json::Map::<String, ::serde_json::Value>::deserialize(deserializer)?;
let tag = raw.get({tag:?}).and_then(::serde_json::Value::as_str);
#[allow(clippy::redundant_closure_call)]
(|raw: ::serde_json::Map<String, ::serde_json::Value>| match tag {{
{de_arms} _ => fallback(raw),
}})(raw.clone())
}}
}}
"#
));
}