1use std::borrow::Cow;23use jrsonnet_interner::{IBytes, IStr};4use jrsonnet_ir::NumValue;5use serde::{6 Deserialize, Serialize, Serializer,7 de::{self, Visitor},8 ser::{9 Error, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,10 SerializeTupleStruct, SerializeTupleVariant,11 },12};1314use crate::{15 Error as JrError, ObjValue, ObjValueBuilder, Result, Val, in_description_frame, runtime_error,16};1718impl<'de> Deserialize<'de> for Val {19 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>20 where21 D: serde::Deserializer<'de>,22 {23 struct ValVisitor;2425 26 27 28 29 30 31 32 33 34 3536 impl<'de> Visitor<'de> for ValVisitor {37 type Value = Val;3839 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>40 where41 E: de::Error,42 {43 Ok(Val::Bool(v))44 }45 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>46 where47 E: de::Error,48 {49 Ok(Val::Num(NumValue::new(v).ok_or_else(|| {50 E::custom("only finite numbers are supported")51 })?))52 }53 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>54 where55 E: de::Error,56 {57 Ok(Val::string(v))58 }5960 61 62 63 64 65 66 67 68 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>69 where70 E: de::Error,71 {72 #[expect(73 clippy::cast_precision_loss,74 reason = "this is how it works with stdlib functions"75 )]76 Ok(Val::Num(NumValue::new(v as f64).expect("no overflow")))77 }78 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>79 where80 E: de::Error,81 {82 #[expect(83 clippy::cast_precision_loss,84 reason = "this is how it works with stdlib functions"85 )]86 Ok(Val::Num(NumValue::new(v as f64).expect("no overflow")))87 }8889 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>90 where91 E: de::Error,92 {93 Ok(Val::arr(IBytes::from(v)))94 }9596 fn visit_none<E>(self) -> Result<Self::Value, E>97 where98 E: de::Error,99 {100 Ok(Val::Null)101 }102 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>103 where104 D: serde::Deserializer<'de>,105 {106 deserializer.deserialize_any(self)107 }108109 fn visit_unit<E>(self) -> Result<Self::Value, E>110 where111 E: de::Error,112 {113 Ok(Val::Null)114 }115116 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>117 where118 D: serde::Deserializer<'de>,119 {120 deserializer.deserialize_any(self)121 }122123 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>124 where125 A: de::SeqAccess<'de>,126 {127 let mut out = seq.size_hint().map_or_else(Vec::new, Vec::with_capacity);128129 while let Some(val) = seq.next_element::<Val>()? {130 out.push(val);131 }132133 Ok(Val::arr(out))134 }135136 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>137 where138 A: de::MapAccess<'de>,139 {140 let mut out = map141 .size_hint()142 .map_or_else(ObjValueBuilder::new, ObjValueBuilder::with_capacity);143144 while let Some((k, v)) = map.next_entry::<Cow<'de, str>, Val>()? {145 146 out.field(k).value(v);147 }148149 Ok(Val::Obj(out.build()))150 }151152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {153 write!(formatter, "any valid jsonnet value")154 }155 }156 deserializer.deserialize_any(ValVisitor)157 }158}159160impl Serialize for Val {161 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>162 where163 S: serde::Serializer,164 {165 match self {166 Self::Bool(v) => serializer.serialize_bool(*v),167 Self::Null => serializer.serialize_none(),168 Self::Str(s) => serializer.serialize_str(&s.clone().into_flat()),169 Self::Num(n) => {170 let n = n.get();171 if n.fract() == 0.0 {172 #[expect(173 clippy::cast_possible_truncation,174 reason = "no correct implementation is possible here; expected"175 )]176 let n = n as i64;177 serializer.serialize_i64(n)178 } else {179 serializer.serialize_f64(n)180 }181 }182 #[cfg(feature = "exp-bigint")]183 Self::BigInt(b) => b.serialize(serializer),184 Self::Arr(arr) => {185 let mut seq = serializer.serialize_seq(Some(arr.len() as usize))?;186 for (i, element) in arr.iter().enumerate() {187 let mut serde_error = None;188 in_description_frame(189 || format!("array index [{i}]"),190 || {191 let e = element?;192 if let Err(e) = seq.serialize_element(&e) {193 serde_error = Some(e);194 }195 Ok(())196 },197 )198 .map_err(|e| S::Error::custom(e.to_string()))?;199 if let Some(e) = serde_error {200 return Err(e);201 }202 }203 seq.end()204 }205 Self::Obj(obj) => {206 let mut map = serializer.serialize_map(Some(obj.len() as usize))?;207 for (field, value) in obj.iter(208 #[cfg(feature = "exp-preserve-order")]209 true,210 ) {211 let mut serde_error = None;212 213 in_description_frame(214 || format!("object field {field:?}"),215 || {216 let v = value?;217 if let Err(e) = map.serialize_entry(field.as_str(), &v) {218 serde_error = Some(e);219 }220 Ok(())221 },222 )223 .map_err(|e| S::Error::custom(e.to_string()))?;224 if let Some(e) = serde_error {225 return Err(e);226 }227 }228 map.end()229 }230 Self::Func(_) => Err(S::Error::custom("tried to manifest function")),231 }232 }233}234235struct IntoVecValSerializer {236 variant: Option<IStr>,237 data: Vec<Val>,238}239impl IntoVecValSerializer {240 fn new() -> Self {241 Self {242 variant: None,243 data: Vec::new(),244 }245 }246 fn with_capacity(capacity: usize) -> Self {247 Self {248 variant: None,249 data: Vec::with_capacity(capacity),250 }251 }252 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {253 Self {254 variant: Some(variant.into()),255 data: Vec::with_capacity(capacity),256 }257 }258}259impl SerializeSeq for IntoVecValSerializer {260 type Ok = Val;261 type Error = JrError;262263 fn serialize_element<T>(&mut self, value: &T) -> Result<()>264 where265 T: ?Sized + Serialize,266 {267 let value = value.serialize(IntoValSerializer)?;268 self.data.push(value);269 Ok(())270 }271272 fn end(self) -> Result<Val> {273 let inner = Val::arr(self.data);274 if let Some(variant) = self.variant {275 let mut out = ObjValue::builder_with_capacity(1);276 out.field(variant).value(inner);277 Ok(Val::Obj(out.build()))278 } else {279 Ok(inner)280 }281 }282}283impl SerializeTuple for IntoVecValSerializer {284 type Ok = Val;285 type Error = JrError;286287 fn serialize_element<T>(&mut self, value: &T) -> Result<()>288 where289 T: ?Sized + Serialize,290 {291 SerializeSeq::serialize_element(self, value)292 }293294 fn end(self) -> Result<Val> {295 SerializeSeq::end(self)296 }297}298impl SerializeTupleVariant for IntoVecValSerializer {299 type Ok = Val;300 type Error = JrError;301302 fn serialize_field<T>(&mut self, value: &T) -> Result<()>303 where304 T: ?Sized + Serialize,305 {306 SerializeSeq::serialize_element(self, value)307 }308309 fn end(self) -> Result<Val> {310 SerializeSeq::end(self)311 }312}313impl SerializeTupleStruct for IntoVecValSerializer {314 type Ok = Val;315 type Error = JrError;316317 fn serialize_field<T>(&mut self, value: &T) -> Result<()>318 where319 T: ?Sized + Serialize,320 {321 SerializeSeq::serialize_element(self, value)322 }323324 fn end(self) -> Result<Val> {325 SerializeSeq::end(self)326 }327}328329struct IntoObjValueSerializer {330 variant: Option<IStr>,331 data: ObjValueBuilder,332 key: Option<IStr>,333}334impl IntoObjValueSerializer {335 fn new() -> Self {336 Self {337 variant: None,338 data: ObjValue::builder(),339 key: None,340 }341 }342 fn with_capacity(capacity: usize) -> Self {343 Self {344 variant: None,345 data: ObjValue::builder_with_capacity(capacity),346 key: None,347 }348 }349 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {350 Self {351 variant: Some(variant.into()),352 data: ObjValue::builder_with_capacity(capacity),353 key: None,354 }355 }356}357impl SerializeMap for IntoObjValueSerializer {358 type Ok = Val;359 type Error = JrError;360361 fn serialize_key<T>(&mut self, key: &T) -> Result<()>362 where363 T: ?Sized + Serialize,364 {365 let key = key.serialize(IntoValSerializer)?;366 let key = key.to_string()?;367 self.key = Some(key);368 Ok(())369 }370371 fn serialize_value<T>(&mut self, value: &T) -> Result<()>372 where373 T: ?Sized + Serialize,374 {375 let key = self.key.take().expect("no serialize_key called");376 let value = value.serialize(IntoValSerializer)?;377 self.data.field(key).try_value(value)?;378 Ok(())379 }380381 382 fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>383 where384 K: ?Sized + Serialize,385 V: ?Sized + Serialize,386 {387 let key = key.serialize(IntoValSerializer)?;388 let key = key.to_string()?;389 let value = value.serialize(IntoValSerializer)?;390 self.data.field(key).try_value(value)?;391 Ok(())392 }393394 fn end(self) -> Result<Val> {395 let inner = Val::Obj(self.data.build());396 if let Some(variant) = self.variant {397 let mut out = ObjValue::builder_with_capacity(1);398 out.field(variant).value(inner);399 Ok(Val::Obj(out.build()))400 } else {401 Ok(inner)402 }403 }404}405impl SerializeStruct for IntoObjValueSerializer {406 type Ok = Val;407 type Error = JrError;408409 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>410 where411 T: ?Sized + Serialize,412 {413 SerializeMap::serialize_entry(self, key, value)?;414 Ok(())415 }416417 fn end(self) -> Result<Val> {418 SerializeMap::end(self)419 }420}421impl SerializeStructVariant for IntoObjValueSerializer {422 type Ok = Val;423424 type Error = JrError;425426 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>427 where428 T: ?Sized + Serialize,429 {430 SerializeMap::serialize_entry(self, key, value)?;431 Ok(())432 }433434 fn end(self) -> Result<Val> {435 SerializeMap::end(self)436 }437}438439struct IntoValSerializer;440impl Serializer for IntoValSerializer {441 type Ok = Val;442443 type Error = JrError;444445 type SerializeSeq = IntoVecValSerializer;446447 type SerializeTuple = IntoVecValSerializer;448449 type SerializeTupleStruct = IntoVecValSerializer;450451 type SerializeTupleVariant = IntoVecValSerializer;452453 type SerializeMap = IntoObjValueSerializer;454455 type SerializeStruct = IntoObjValueSerializer;456457 type SerializeStructVariant = IntoObjValueSerializer;458459 fn serialize_bool(self, v: bool) -> Result<Val> {460 Ok(Val::Bool(v))461 }462463 fn serialize_i8(self, v: i8) -> Result<Val> {464 Ok(Val::Num(v.into()))465 }466467 fn serialize_i16(self, v: i16) -> Result<Val> {468 Ok(Val::Num(v.into()))469 }470471 fn serialize_i32(self, v: i32) -> Result<Val> {472 Ok(Val::Num(v.into()))473 }474475 fn serialize_i64(self, v: i64) -> Result<Val> {476 Ok(Val::Str(v.to_string().into()))477 }478479 fn serialize_u8(self, v: u8) -> Result<Val> {480 Ok(Val::Num(v.into()))481 }482483 fn serialize_u16(self, v: u16) -> Result<Val> {484 Ok(Val::Num(v.into()))485 }486487 fn serialize_u32(self, v: u32) -> Result<Val> {488 Ok(Val::Num(v.into()))489 }490491 fn serialize_u64(self, v: u64) -> Result<Val> {492 Ok(Val::Str(v.to_string().into()))493 }494495 fn serialize_f32(self, v: f32) -> Result<Val> {496 Ok(Val::try_num(f64::from(v))?)497 }498499 fn serialize_f64(self, v: f64) -> Result<Val> {500 Ok(Val::try_num(v)?)501 }502503 fn serialize_char(self, v: char) -> Result<Val> {504 Ok(Val::Str(v.to_string().into()))505 }506507 fn serialize_str(self, v: &str) -> Result<Val> {508 Ok(Val::Str(v.into()))509 }510511 fn serialize_bytes(self, v: &[u8]) -> Result<Val> {512 Ok(Val::arr(IBytes::from(v)))513 }514515 fn serialize_none(self) -> Result<Val> {516 Ok(Val::Null)517 }518519 fn serialize_some<T>(self, value: &T) -> Result<Val>520 where521 T: ?Sized + Serialize,522 {523 value.serialize(self)524 }525526 fn serialize_unit(self) -> Result<Val> {527 Ok(Val::Null)528 }529530 fn serialize_unit_struct(self, _name: &'static str) -> Result<Val> {531 Ok(Val::Null)532 }533534 fn serialize_unit_variant(535 self,536 _name: &'static str,537 _variant_index: u32,538 variant: &'static str,539 ) -> Result<Val> {540 Ok(Val::Str(variant.into()))541 }542543 fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Val>544 where545 T: ?Sized + Serialize,546 {547 value.serialize(self)548 }549550 fn serialize_newtype_variant<T>(551 self,552 _name: &'static str,553 _variant_index: u32,554 variant: &'static str,555 value: &T,556 ) -> Result<Val>557 where558 T: ?Sized + Serialize,559 {560 let mut out = ObjValue::builder_with_capacity(1);561 let value = value.serialize(self)?;562 out.field(variant).value(value);563 Ok(Val::Obj(out.build()))564 }565566 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {567 Ok(len.map_or_else(568 IntoVecValSerializer::new,569 IntoVecValSerializer::with_capacity,570 ))571 }572573 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {574 Ok(IntoVecValSerializer::with_capacity(len))575 }576577 fn serialize_tuple_struct(578 self,579 _name: &'static str,580 len: usize,581 ) -> Result<Self::SerializeTupleStruct, Self::Error> {582 Ok(IntoVecValSerializer::with_capacity(len))583 }584585 fn serialize_tuple_variant(586 self,587 _name: &'static str,588 _variant_index: u32,589 variant: &'static str,590 len: usize,591 ) -> Result<Self::SerializeTupleVariant, Self::Error> {592 Ok(IntoVecValSerializer::variant_with_capacity(variant, len))593 }594595 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {596 Ok(len.map_or_else(597 IntoObjValueSerializer::new,598 IntoObjValueSerializer::with_capacity,599 ))600 }601602 fn serialize_struct(603 self,604 _name: &'static str,605 len: usize,606 ) -> Result<Self::SerializeStruct, Self::Error> {607 Ok(IntoObjValueSerializer::with_capacity(len))608 }609610 fn serialize_struct_variant(611 self,612 _name: &'static str,613 _variant_index: u32,614 variant: &'static str,615 len: usize,616 ) -> Result<Self::SerializeStructVariant, Self::Error> {617 Ok(IntoObjValueSerializer::variant_with_capacity(variant, len))618 }619}620621impl Val {622 pub fn from_serde(v: impl Serialize) -> Result<Self, JrError> {623 v.serialize(IntoValSerializer)624 }625}626627impl serde::ser::Error for JrError {628 fn custom<T>(msg: T) -> Self629 where630 T: std::fmt::Display,631 {632 runtime_error!("serde: {msg}")633 }634}