1082 lines
44 KiB
Rust
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())
|
|
}}
|
|
}}
|
|
|
|
"#
|
|
));
|
|
}
|