1#![allow(dead_code)]
16
17use error::{Error, Result};
18use serde::{
19 de, ser,
20 ser::{SerializeMap, SerializeStruct},
21 Deserialize, Serialize,
22};
23use std::{
24 cell::{Ref, RefCell, RefMut},
25 collections::{btree_map::Entry, BTreeMap},
26 rc::Rc,
27};
28
29use super::error;
30
31#[derive(Serialize, Deserialize, Debug, Eq, Clone, PartialEq, Hash)]
33#[serde(rename_all = "UPPERCASE")]
34pub enum Format {
35 Variable(#[serde(with = "not_implemented")] Variable<Format>),
37 TypeName(String),
39
40 Unit,
42 Bool,
43 I8,
44 I16,
45 I32,
46 I64,
47 I128,
48 U8,
49 U16,
50 U32,
51 U64,
52 U128,
53 F32,
54 F64,
55 Char,
56 Str,
57 Bytes,
58
59 Option(Box<Format>),
61 Seq(Box<Format>),
63 #[serde(rename_all = "UPPERCASE")]
65 Map {
66 key: Box<Format>,
67 value: Box<Format>,
68 },
69
70 Tuple(Vec<Format>),
72 #[serde(rename_all = "UPPERCASE")]
75 TupleArray {
76 content: Box<Format>,
77 size: usize,
78 },
79}
80
81#[derive(Serialize, Deserialize, Debug, Eq, Clone, PartialEq, Hash)]
84#[serde(rename_all = "UPPERCASE")]
85pub enum ContainerFormat {
86 UnitStruct,
88 NewTypeStruct(Box<Format>),
90 TupleStruct(Vec<Format>),
92 Struct(Vec<Named<Format>>),
94 Enum(BTreeMap<usize, Named<VariantFormat>>),
97}
98
99#[derive(Debug, Clone, Default, Eq, PartialEq, Hash)]
100pub struct Named<T> {
103 pub name: String,
104 pub value: T,
105}
106
107#[derive(Debug, Clone, Default, Eq, PartialEq)]
108pub struct Variable<T>(Rc<RefCell<Option<T>>>);
110
111impl<T: std::hash::Hash> std::hash::Hash for Variable<T> {
112 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
113 self.0.borrow().hash(state);
114 }
115}
116
117#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq, Hash)]
118#[serde(rename_all = "UPPERCASE")]
119pub enum VariantFormat {
121 Variable(#[serde(with = "not_implemented")] Variable<VariantFormat>),
123 Unit,
125 NewType(Box<Format>),
127 Tuple(Vec<Format>),
129 Struct(Vec<Named<Format>>),
131}
132
133pub trait FormatHolder {
135 fn visit<'a>(&'a self, f: &mut dyn FnMut(&'a Format) -> Result<()>) -> Result<()>;
138
139 fn visit_mut(&mut self, f: &mut dyn FnMut(&mut Format) -> Result<()>) -> Result<()>;
144
145 fn unify(&mut self, other: Self) -> Result<()>;
154
155 fn normalize(&mut self) -> Result<()> {
159 self.visit_mut(&mut |format: &mut Format| {
160 let normalized = match format {
161 Format::Tuple(formats) => {
162 let size = formats.len();
163 if size <= 1 {
164 return Ok(());
165 }
166 let format0 = &formats[0];
167 for format in formats.iter().skip(1) {
168 if format != format0 {
169 return Ok(());
170 }
171 }
172 Format::TupleArray {
173 content: Box::new(std::mem::take(&mut formats[0])),
174 size,
175 }
176 }
177 _ => {
178 return Ok(());
179 }
180 };
181 *format = normalized;
182 Ok(())
183 })
184 }
185
186 fn reduce(&mut self) {
189 self.visit_mut(&mut |_| Ok(())).unwrap_or(());
190 }
191
192 fn is_unknown(&self) -> bool;
194}
195
196fn unification_error<T1, T2>(v1: T1, v2: T2) -> Error
197where
198 T1: std::fmt::Debug,
199 T2: std::fmt::Debug,
200{
201 Error::Incompatible(format!("{v1:?}"), format!("{v2:?}"))
202}
203
204impl FormatHolder for VariantFormat {
205 fn visit<'a>(&'a self, f: &mut dyn FnMut(&'a Format) -> Result<()>) -> Result<()> {
206 match self {
207 Self::Variable(variable) => variable.visit(f)?,
208 Self::Unit => (),
209 Self::NewType(format) => format.visit(f)?,
210 Self::Tuple(formats) => {
211 for format in formats {
212 format.visit(f)?;
213 }
214 }
215 Self::Struct(named_formats) => {
216 for format in named_formats {
217 format.visit(f)?;
218 }
219 }
220 }
221 Ok(())
222 }
223
224 fn visit_mut(&mut self, f: &mut dyn FnMut(&mut Format) -> Result<()>) -> Result<()> {
225 match self {
226 Self::Variable(variable) => {
227 variable.visit_mut(f)?;
228 *self = std::mem::take(variable)
231 .into_inner()
232 .expect("variable is known");
233 }
234 Self::Unit => (),
235 Self::NewType(format) => {
236 format.visit_mut(f)?;
237 }
238 Self::Tuple(formats) => {
239 for format in formats {
240 format.visit_mut(f)?;
241 }
242 }
243 Self::Struct(named_formats) => {
244 for format in named_formats {
245 format.visit_mut(f)?;
246 }
247 }
248 }
249 Ok(())
250 }
251
252 fn unify(&mut self, format: VariantFormat) -> Result<()> {
253 match (self, format) {
254 (format1, Self::Variable(variable2)) => {
255 if let Some(format2) = &mut *variable2.borrow_mut() {
256 format1.unify(std::mem::take(format2))?;
257 }
258 *variable2.borrow_mut() = Some(format1.clone());
259 }
260 (Self::Variable(variable1), format2) => {
261 let inner_variable = match &mut *variable1.borrow_mut() {
262 value1 @ None => {
263 *value1 = Some(format2);
264 None
265 }
266 Some(format1) => {
267 format1.unify(format2)?;
268 match format1 {
269 Self::Variable(variable) => Some(variable.clone()),
270 _ => None,
271 }
272 }
273 };
274 if let Some(variable) = inner_variable {
276 *variable1 = variable;
277 }
278 }
279
280 (Self::Unit, Self::Unit) => (),
281
282 (Self::NewType(format1), Self::NewType(format2)) => {
283 format1.as_mut().unify(*format2)?;
284 }
285
286 (Self::Tuple(formats1), Self::Tuple(formats2)) if formats1.len() == formats2.len() => {
287 for (format1, format2) in formats1.iter_mut().zip(formats2.into_iter()) {
288 format1.unify(format2)?;
289 }
290 }
291
292 (Self::Struct(named_formats1), Self::Struct(named_formats2))
293 if named_formats1.len() == named_formats2.len() =>
294 {
295 for (format1, format2) in named_formats1.iter_mut().zip(named_formats2.into_iter())
296 {
297 format1.unify(format2)?;
298 }
299 }
300
301 (format1, format2) => {
302 return Err(unification_error(format1, format2));
303 }
304 }
305 Ok(())
306 }
307
308 fn is_unknown(&self) -> bool {
309 if let Self::Variable(v) = self {
310 return v.is_unknown();
311 }
312 false
313 }
314}
315
316impl<T> FormatHolder for Named<T>
317where
318 T: FormatHolder + std::fmt::Debug,
319{
320 fn visit<'a>(&'a self, f: &mut dyn FnMut(&'a Format) -> Result<()>) -> Result<()> {
321 self.value.visit(f)
322 }
323
324 fn visit_mut(&mut self, f: &mut dyn FnMut(&mut Format) -> Result<()>) -> Result<()> {
325 self.value.visit_mut(f)
326 }
327
328 fn unify(&mut self, other: Named<T>) -> Result<()> {
329 if self.name != other.name {
330 return Err(unification_error(&*self, &other));
331 }
332 self.value.unify(other.value)
333 }
334
335 fn is_unknown(&self) -> bool {
336 false
337 }
338}
339
340impl<T> Variable<T> {
341 pub(crate) fn new(content: Option<T>) -> Self {
342 Self(Rc::new(RefCell::new(content)))
343 }
344
345 pub fn borrow(&self) -> Ref<Option<T>> {
346 self.0.as_ref().borrow()
347 }
348
349 pub fn borrow_mut(&self) -> RefMut<Option<T>> {
350 self.0.as_ref().borrow_mut()
351 }
352}
353
354impl<T> Variable<T>
355where
356 T: Clone,
357{
358 fn into_inner(self) -> Option<T> {
359 match Rc::try_unwrap(self.0) {
360 Ok(cell) => cell.into_inner(),
361 Err(rc) => rc.borrow().clone(),
362 }
363 }
364}
365
366mod not_implemented {
367 pub fn serialize<T, S>(_: &T, _serializer: S) -> Result<S::Ok, S::Error>
368 where
369 S: serde::ser::Serializer,
370 {
371 use serde::ser::Error;
372 Err(S::Error::custom("Cannot serialize variables"))
373 }
374
375 pub fn deserialize<'de, T, D>(_deserializer: D) -> Result<T, D::Error>
376 where
377 D: serde::de::Deserializer<'de>,
378 {
379 use serde::de::Error;
380 Err(D::Error::custom("Cannot deserialize variables"))
381 }
382}
383
384impl<T> FormatHolder for Variable<T>
385where
386 T: FormatHolder + std::fmt::Debug + Clone,
387{
388 fn visit<'a>(&'a self, _f: &mut dyn FnMut(&'a Format) -> Result<()>) -> Result<()> {
389 Err(Error::NotSupported(
390 "Cannot immutability visit formats with variables",
391 ))
392 }
393
394 fn visit_mut(&mut self, f: &mut dyn FnMut(&mut Format) -> Result<()>) -> Result<()> {
395 match &mut *self.borrow_mut() {
396 None => Err(Error::UnknownFormat),
397 Some(value) => value.visit_mut(f),
398 }
399 }
400
401 fn unify(&mut self, _other: Variable<T>) -> Result<()> {
402 Err(Error::NotSupported("Cannot unify variables directly"))
405 }
406
407 fn is_unknown(&self) -> bool {
408 match self.borrow().as_ref() {
409 None => true,
410 Some(format) => format.is_unknown(),
411 }
412 }
413}
414
415impl FormatHolder for ContainerFormat {
416 fn visit<'a>(&'a self, f: &mut dyn FnMut(&'a Format) -> Result<()>) -> Result<()> {
417 match self {
418 Self::UnitStruct => (),
419 Self::NewTypeStruct(format) => format.visit(f)?,
420 Self::TupleStruct(formats) => {
421 for format in formats {
422 format.visit(f)?;
423 }
424 }
425 Self::Struct(named_formats) => {
426 for format in named_formats {
427 format.visit(f)?;
428 }
429 }
430 Self::Enum(variants) => {
431 for variant in variants {
432 variant.1.visit(f)?;
433 }
434 }
435 }
436 Ok(())
437 }
438
439 fn visit_mut(&mut self, f: &mut dyn FnMut(&mut Format) -> Result<()>) -> Result<()> {
440 match self {
441 Self::UnitStruct => (),
442 Self::NewTypeStruct(format) => format.visit_mut(f)?,
443 Self::TupleStruct(formats) => {
444 for format in formats {
445 format.visit_mut(f)?;
446 }
447 }
448 Self::Struct(named_formats) => {
449 for format in named_formats {
450 format.visit_mut(f)?;
451 }
452 }
453 Self::Enum(variants) => {
454 for variant in variants {
455 variant.1.visit_mut(f)?;
456 }
457 }
458 }
459 Ok(())
460 }
461
462 fn unify(&mut self, format: ContainerFormat) -> Result<()> {
463 match (self, format) {
464 (Self::UnitStruct, Self::UnitStruct) => (),
465
466 (Self::NewTypeStruct(format1), Self::NewTypeStruct(format2)) => {
467 format1.as_mut().unify(*format2)?;
468 }
469
470 (Self::TupleStruct(formats1), Self::TupleStruct(formats2))
471 if formats1.len() == formats2.len() =>
472 {
473 for (format1, format2) in formats1.iter_mut().zip(formats2.into_iter()) {
474 format1.unify(format2)?;
475 }
476 }
477
478 (Self::Struct(named_formats1), Self::Struct(named_formats2))
479 if named_formats1.len() == named_formats2.len() =>
480 {
481 for (format1, format2) in named_formats1.iter_mut().zip(named_formats2.into_iter())
482 {
483 format1.unify(format2)?;
484 }
485 }
486
487 (Self::Enum(variants1), Self::Enum(variants2)) => {
488 for (index2, variant2) in variants2 {
489 match variants1.entry(index2) {
490 Entry::Vacant(e) => {
491 e.insert(variant2);
493 }
494 Entry::Occupied(mut e) => {
495 e.get_mut().unify(variant2)?;
496 }
497 }
498 }
499 }
500
501 (format1, format2) => {
502 return Err(unification_error(format1, format2));
503 }
504 }
505 Ok(())
506 }
507
508 fn is_unknown(&self) -> bool {
509 false
510 }
511}
512
513impl FormatHolder for Format {
514 fn visit<'a>(&'a self, f: &mut dyn FnMut(&'a Format) -> Result<()>) -> Result<()> {
515 match self {
516 Self::Variable(variable) => variable.visit(f)?,
517 Self::TypeName(_)
518 | Self::Unit
519 | Self::Bool
520 | Self::I8
521 | Self::I16
522 | Self::I32
523 | Self::I64
524 | Self::I128
525 | Self::U8
526 | Self::U16
527 | Self::U32
528 | Self::U64
529 | Self::U128
530 | Self::F32
531 | Self::F64
532 | Self::Char
533 | Self::Str
534 | Self::Bytes => (),
535
536 Self::Option(format)
537 | Self::Seq(format)
538 | Self::TupleArray {
539 content: format, ..
540 } => {
541 format.visit(f)?;
542 }
543
544 Self::Map { key, value } => {
545 key.visit(f)?;
546 value.visit(f)?;
547 }
548
549 Self::Tuple(formats) => {
550 for format in formats {
551 format.visit(f)?;
552 }
553 }
554 }
555 f(self)
556 }
557
558 fn visit_mut(&mut self, f: &mut dyn FnMut(&mut Format) -> Result<()>) -> Result<()> {
559 match self {
560 Self::Variable(variable) => {
561 variable.visit_mut(f)?;
562 *self = std::mem::take(variable)
565 .into_inner()
566 .expect("variable is known");
567 }
568 Self::TypeName(_)
569 | Self::Unit
570 | Self::Bool
571 | Self::I8
572 | Self::I16
573 | Self::I32
574 | Self::I64
575 | Self::I128
576 | Self::U8
577 | Self::U16
578 | Self::U32
579 | Self::U64
580 | Self::U128
581 | Self::F32
582 | Self::F64
583 | Self::Char
584 | Self::Str
585 | Self::Bytes => (),
586
587 Self::Option(format)
588 | Self::Seq(format)
589 | Self::TupleArray {
590 content: format, ..
591 } => {
592 format.visit_mut(f)?;
593 }
594
595 Self::Map { key, value } => {
596 key.visit_mut(f)?;
597 value.visit_mut(f)?;
598 }
599
600 Self::Tuple(formats) => {
601 for format in formats {
602 format.visit_mut(f)?;
603 }
604 }
605 }
606 f(self)
607 }
608
609 fn unify(&mut self, format: Format) -> Result<()> {
612 match (self, format) {
613 (format1, Self::Variable(variable2)) => {
614 if let Some(format2) = &mut *variable2.borrow_mut() {
615 format1.unify(std::mem::take(format2))?;
616 }
617 *variable2.borrow_mut() = Some(format1.clone());
618 }
619 (Self::Variable(variable1), format2) => {
620 let inner_variable = match &mut *variable1.borrow_mut() {
621 value1 @ None => {
622 *value1 = Some(format2);
623 None
624 }
625 Some(format1) => {
626 format1.unify(format2)?;
627 match format1 {
628 Self::Variable(variable) => Some(variable.clone()),
629 _ => None,
630 }
631 }
632 };
633 if let Some(variable) = inner_variable {
635 *variable1 = variable;
636 }
637 }
638
639 (Self::Unit, Self::Unit)
640 | (Self::Bool, Self::Bool)
641 | (Self::I8, Self::I8)
642 | (Self::I16, Self::I16)
643 | (Self::I32, Self::I32)
644 | (Self::I64, Self::I64)
645 | (Self::I128, Self::I128)
646 | (Self::U8, Self::U8)
647 | (Self::U16, Self::U16)
648 | (Self::U32, Self::U32)
649 | (Self::U64, Self::U64)
650 | (Self::U128, Self::U128)
651 | (Self::F32, Self::F32)
652 | (Self::F64, Self::F64)
653 | (Self::Char, Self::Char)
654 | (Self::Str, Self::Str)
655 | (Self::Bytes, Self::Bytes) => (),
656
657 (Self::TypeName(name1), Self::TypeName(name2)) if *name1 == name2 => (),
658
659 (Self::Option(format1), Self::Option(format2))
660 | (Self::Seq(format1), Self::Seq(format2)) => {
661 format1.as_mut().unify(*format2)?;
662 }
663
664 (Self::Tuple(formats1), Self::Tuple(formats2)) if formats1.len() == formats2.len() => {
665 for (format1, format2) in formats1.iter_mut().zip(formats2.into_iter()) {
666 format1.unify(format2)?;
667 }
668 }
669
670 (
671 Self::Map {
672 key: key1,
673 value: value1,
674 },
675 Self::Map {
676 key: key2,
677 value: value2,
678 },
679 ) => {
680 key1.as_mut().unify(*key2)?;
681 value1.as_mut().unify(*value2)?;
682 }
683
684 (format1, format2) => {
685 return Err(unification_error(format1, format2));
686 }
687 }
688 Ok(())
689 }
690
691 fn is_unknown(&self) -> bool {
692 if let Self::Variable(v) = self {
693 return v.is_unknown();
694 }
695 false
696 }
697}
698
699pub(crate) trait ContainerFormatEntry {
701 fn unify(self, format: ContainerFormat) -> Result<()>;
702}
703
704impl<K> ContainerFormatEntry for Entry<'_, K, ContainerFormat>
705where
706 K: std::cmp::Ord,
707{
708 fn unify(self, format: ContainerFormat) -> Result<()> {
709 match self {
710 Entry::Vacant(e) => {
711 e.insert(format);
712 Ok(())
713 }
714 Entry::Occupied(e) => e.into_mut().unify(format),
715 }
716 }
717}
718
719impl Format {
720 pub fn unknown() -> Self {
722 Self::Variable(Variable::new(None))
723 }
724}
725
726impl VariantFormat {
727 pub fn unknown() -> Self {
729 Self::Variable(Variable::new(None))
730 }
731}
732
733impl Default for Format {
734 fn default() -> Self {
735 Self::unknown()
736 }
737}
738
739impl Default for VariantFormat {
740 fn default() -> Self {
741 Self::unknown()
742 }
743}
744
745impl<T> Serialize for Named<T>
748where
749 T: Serialize,
750{
751 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
752 where
753 S: ser::Serializer,
754 {
755 if serializer.is_human_readable() {
756 let mut map = serializer.serialize_map(Some(1))?;
757 map.serialize_entry(&self.name, &self.value)?;
758 map.end()
759 } else {
760 let mut inner = serializer.serialize_struct("Named", 2)?;
761 inner.serialize_field("name", &self.name)?;
762 inner.serialize_field("value", &self.value)?;
763 inner.end()
764 }
765 }
766}
767
768struct NamedVisitor<T> {
769 marker: std::marker::PhantomData<T>,
770}
771
772impl<T> NamedVisitor<T> {
773 fn new() -> Self {
774 Self {
775 marker: std::marker::PhantomData,
776 }
777 }
778}
779
780impl<'de, T> de::Visitor<'de> for NamedVisitor<T>
781where
782 T: Deserialize<'de>,
783{
784 type Value = Named<T>;
785
786 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
787 formatter.write_str("a single entry map")
788 }
789
790 fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
791 where
792 M: de::MapAccess<'de>,
793 {
794 let named_value = match access.next_entry::<String, T>()? {
795 Some((name, value)) => Named { name, value },
796 _ => {
797 return Err(de::Error::custom("Missing entry"));
798 }
799 };
800 if access.next_entry::<String, T>()?.is_some() {
801 return Err(de::Error::custom("Too many entries"));
802 }
803 Ok(named_value)
804 }
805}
806
807#[derive(Deserialize)]
809#[serde(rename = "Named")]
810struct NamedInternal<T> {
811 name: String,
812 value: T,
813}
814
815impl<'de, T> Deserialize<'de> for Named<T>
816where
817 T: Deserialize<'de>,
818{
819 fn deserialize<D>(deserializer: D) -> Result<Named<T>, D::Error>
820 where
821 D: de::Deserializer<'de>,
822 {
823 if deserializer.is_human_readable() {
824 deserializer.deserialize_map(NamedVisitor::new())
825 } else {
826 let NamedInternal { name, value } = NamedInternal::deserialize(deserializer)?;
827 Ok(Self { name, value })
828 }
829 }
830}