1use crate::error::Error;
2use crate::token::Token;
3use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
4use serde::de::{
5 self, Deserialize, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess,
6 VariantAccess, Visitor,
7};
8use serde::forward_to_deserialize_any;
9
10#[derive(Debug)]
11pub struct Deserializer<'de> {
12 tokens: &'de [Token],
13}
14
15fn assert_next_token(de: &mut Deserializer, expected: Token) -> Result<(), Error> {
16 match de.next_token_opt() {
17 Some(token) if token == expected => Ok(()),
18 Some(other) => Err(de::Error::custom(format!(
19 "expected Token::{} but deserialization wants Token::{}",
20 other, expected,
21 ))),
22 None => Err(de::Error::custom(format!(
23 "end of tokens but deserialization wants Token::{}",
24 expected,
25 ))),
26 }
27}
28
29fn unexpected(token: Token) -> Error {
30 de::Error::custom(format!(
31 "deserialization did not expect this token: {}",
32 token,
33 ))
34}
35
36fn end_of_tokens() -> Error {
37 de::Error::custom("ran out of tokens to deserialize")
38}
39
40impl<'de> Deserializer<'de> {
41 pub fn new(tokens: &'de [Token]) -> Self {
42 Deserializer { tokens }
43 }
44
45 fn peek_token_opt(&self) -> Option<Token> {
46 self.tokens.first().copied()
47 }
48
49 fn peek_token(&self) -> Result<Token, Error> {
50 self.peek_token_opt().ok_or_else(end_of_tokens)
51 }
52
53 pub fn next_token_opt(&mut self) -> Option<Token> {
54 match self.tokens.split_first() {
55 Some((&first, rest)) => {
56 self.tokens = rest;
57 Some(first)
58 }
59 None => None,
60 }
61 }
62
63 fn next_token(&mut self) -> Result<Token, Error> {
64 let (&first, rest) = self.tokens.split_first().ok_or_else(end_of_tokens)?;
65 self.tokens = rest;
66 Ok(first)
67 }
68
69 pub fn remaining(&self) -> usize {
70 self.tokens.len()
71 }
72
73 fn visit_seq<V>(
74 &mut self,
75 len: Option<usize>,
76 end: Token,
77 visitor: V,
78 ) -> Result<V::Value, Error>
79 where
80 V: Visitor<'de>,
81 {
82 let value = visitor.visit_seq(DeserializerSeqVisitor { de: self, len, end })?;
83 assert_next_token(self, end)?;
84 Ok(value)
85 }
86
87 fn visit_map<V>(
88 &mut self,
89 len: Option<usize>,
90 end: Token,
91 visitor: V,
92 ) -> Result<V::Value, Error>
93 where
94 V: Visitor<'de>,
95 {
96 let value = visitor.visit_map(DeserializerMapVisitor { de: self, len, end })?;
97 assert_next_token(self, end)?;
98 Ok(value)
99 }
100}
101
102impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
103 type Error = Error;
104
105 forward_to_deserialize_any! {
106 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
107 bytes byte_buf unit seq map identifier ignored_any
108 }
109
110 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
111 where
112 V: Visitor<'de>,
113 {
114 let token = self.next_token()?;
115 match token {
116 Token::Bool(v) => visitor.visit_bool(v),
117 Token::I8(v) => visitor.visit_i8(v),
118 Token::I16(v) => visitor.visit_i16(v),
119 Token::I32(v) => visitor.visit_i32(v),
120 Token::I64(v) => visitor.visit_i64(v),
121 Token::U8(v) => visitor.visit_u8(v),
122 Token::U16(v) => visitor.visit_u16(v),
123 Token::U32(v) => visitor.visit_u32(v),
124 Token::U64(v) => visitor.visit_u64(v),
125 Token::F32(v) => visitor.visit_f32(v),
126 Token::F64(v) => visitor.visit_f64(v),
127 Token::Char(v) => visitor.visit_char(v),
128 Token::Str(v) => visitor.visit_str(v),
129 Token::BorrowedStr(v) => visitor.visit_borrowed_str(v),
130 Token::String(v) => visitor.visit_string(v.to_owned()),
131 Token::Bytes(v) => visitor.visit_bytes(v),
132 Token::BorrowedBytes(v) => visitor.visit_borrowed_bytes(v),
133 Token::ByteBuf(v) => visitor.visit_byte_buf(v.to_vec()),
134 Token::None => visitor.visit_none(),
135 Token::Some => visitor.visit_some(self),
136 Token::Unit | Token::UnitStruct { .. } => visitor.visit_unit(),
137 Token::NewtypeStruct { .. } => visitor.visit_newtype_struct(self),
138 Token::Seq { len } => self.visit_seq(len, Token::SeqEnd, visitor),
139 Token::Tuple { len } => self.visit_seq(Some(len), Token::TupleEnd, visitor),
140 Token::TupleStruct { len, .. } => {
141 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
142 }
143 Token::Map { len } => self.visit_map(len, Token::MapEnd, visitor),
144 Token::Struct { len, .. } => self.visit_map(Some(len), Token::StructEnd, visitor),
145 Token::Enum { .. } => {
146 let variant = self.next_token()?;
147 let next = self.peek_token()?;
148 match (variant, next) {
149 (Token::Str(variant), Token::Unit) => {
150 self.next_token()?;
151 visitor.visit_str(variant)
152 }
153 (Token::BorrowedStr(variant), Token::Unit) => {
154 self.next_token()?;
155 visitor.visit_borrowed_str(variant)
156 }
157 (Token::String(variant), Token::Unit) => {
158 self.next_token()?;
159 visitor.visit_string(variant.to_string())
160 }
161 (Token::Bytes(variant), Token::Unit) => {
162 self.next_token()?;
163 visitor.visit_bytes(variant)
164 }
165 (Token::BorrowedBytes(variant), Token::Unit) => {
166 self.next_token()?;
167 visitor.visit_borrowed_bytes(variant)
168 }
169 (Token::ByteBuf(variant), Token::Unit) => {
170 self.next_token()?;
171 visitor.visit_byte_buf(variant.to_vec())
172 }
173 (Token::U8(variant), Token::Unit) => {
174 self.next_token()?;
175 visitor.visit_u8(variant)
176 }
177 (Token::U16(variant), Token::Unit) => {
178 self.next_token()?;
179 visitor.visit_u16(variant)
180 }
181 (Token::U32(variant), Token::Unit) => {
182 self.next_token()?;
183 visitor.visit_u32(variant)
184 }
185 (Token::U64(variant), Token::Unit) => {
186 self.next_token()?;
187 visitor.visit_u64(variant)
188 }
189 (variant, Token::Unit) => Err(unexpected(variant)),
190 (variant, _) => {
191 visitor.visit_map(EnumMapVisitor::new(self, variant, EnumFormat::Any))
192 }
193 }
194 }
195 Token::UnitVariant { variant, .. } => visitor.visit_str(variant),
196 Token::NewtypeVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
197 self,
198 Token::Str(variant),
199 EnumFormat::Any,
200 )),
201 Token::TupleVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
202 self,
203 Token::Str(variant),
204 EnumFormat::Seq,
205 )),
206 Token::StructVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
207 self,
208 Token::Str(variant),
209 EnumFormat::Map,
210 )),
211 Token::SeqEnd
212 | Token::TupleEnd
213 | Token::TupleStructEnd
214 | Token::MapEnd
215 | Token::StructEnd
216 | Token::TupleVariantEnd
217 | Token::StructVariantEnd => Err(unexpected(token)),
218 }
219 }
220
221 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
222 where
223 V: Visitor<'de>,
224 {
225 match self.peek_token()? {
226 Token::Unit | Token::None => {
227 self.next_token()?;
228 visitor.visit_none()
229 }
230 Token::Some => {
231 self.next_token()?;
232 visitor.visit_some(self)
233 }
234 _ => self.deserialize_any(visitor),
235 }
236 }
237
238 fn deserialize_enum<V>(
239 self,
240 name: &'static str,
241 _variants: &'static [&'static str],
242 visitor: V,
243 ) -> Result<V::Value, Error>
244 where
245 V: Visitor<'de>,
246 {
247 match self.peek_token()? {
248 Token::Enum { name: n } if name == n => {
249 self.next_token()?;
250
251 visitor.visit_enum(DeserializerEnumVisitor { de: self })
252 }
253 Token::UnitVariant { name: n, .. }
254 | Token::NewtypeVariant { name: n, .. }
255 | Token::TupleVariant { name: n, .. }
256 | Token::StructVariant { name: n, .. }
257 if name == n =>
258 {
259 visitor.visit_enum(DeserializerEnumVisitor { de: self })
260 }
261 _ => self.deserialize_any(visitor),
262 }
263 }
264
265 fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Error>
266 where
267 V: Visitor<'de>,
268 {
269 match self.peek_token()? {
270 Token::UnitStruct { .. } => {
271 assert_next_token(self, Token::UnitStruct { name })?;
272 visitor.visit_unit()
273 }
274 _ => self.deserialize_any(visitor),
275 }
276 }
277
278 fn deserialize_newtype_struct<V>(
279 self,
280 name: &'static str,
281 visitor: V,
282 ) -> Result<V::Value, Error>
283 where
284 V: Visitor<'de>,
285 {
286 match self.peek_token()? {
287 Token::NewtypeStruct { .. } => {
288 assert_next_token(self, Token::NewtypeStruct { name })?;
289 visitor.visit_newtype_struct(self)
290 }
291 _ => self.deserialize_any(visitor),
292 }
293 }
294
295 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Error>
296 where
297 V: Visitor<'de>,
298 {
299 match self.peek_token()? {
300 Token::Unit | Token::UnitStruct { .. } => {
301 self.next_token()?;
302 visitor.visit_unit()
303 }
304 Token::Seq { .. } => {
305 self.next_token()?;
306 self.visit_seq(Some(len), Token::SeqEnd, visitor)
307 }
308 Token::Tuple { .. } => {
309 self.next_token()?;
310 self.visit_seq(Some(len), Token::TupleEnd, visitor)
311 }
312 Token::TupleStruct { .. } => {
313 self.next_token()?;
314 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
315 }
316 _ => self.deserialize_any(visitor),
317 }
318 }
319
320 fn deserialize_tuple_struct<V>(
321 self,
322 name: &'static str,
323 len: usize,
324 visitor: V,
325 ) -> Result<V::Value, Error>
326 where
327 V: Visitor<'de>,
328 {
329 match self.peek_token()? {
330 Token::Unit => {
331 self.next_token()?;
332 visitor.visit_unit()
333 }
334 Token::UnitStruct { .. } => {
335 assert_next_token(self, Token::UnitStruct { name })?;
336 visitor.visit_unit()
337 }
338 Token::Seq { .. } => {
339 self.next_token()?;
340 self.visit_seq(Some(len), Token::SeqEnd, visitor)
341 }
342 Token::Tuple { .. } => {
343 self.next_token()?;
344 self.visit_seq(Some(len), Token::TupleEnd, visitor)
345 }
346 Token::TupleStruct { len: n, .. } => {
347 assert_next_token(self, Token::TupleStruct { name, len: n })?;
348 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
349 }
350 _ => self.deserialize_any(visitor),
351 }
352 }
353
354 fn deserialize_struct<V>(
355 self,
356 name: &'static str,
357 fields: &'static [&'static str],
358 visitor: V,
359 ) -> Result<V::Value, Error>
360 where
361 V: Visitor<'de>,
362 {
363 match self.peek_token()? {
364 Token::Struct { len: n, .. } => {
365 assert_next_token(self, Token::Struct { name, len: n })?;
366 self.visit_map(Some(fields.len()), Token::StructEnd, visitor)
367 }
368 Token::Map { .. } => {
369 self.next_token()?;
370 self.visit_map(Some(fields.len()), Token::MapEnd, visitor)
371 }
372 _ => self.deserialize_any(visitor),
373 }
374 }
375
376 fn is_human_readable(&self) -> bool {
377 panic!(
378 "Types which have different human-readable and compact representations \
379 must explicitly mark their test cases with `serde_test::Configure`"
380 );
381 }
382}
383
384struct DeserializerSeqVisitor<'a, 'de: 'a> {
387 de: &'a mut Deserializer<'de>,
388 len: Option<usize>,
389 end: Token,
390}
391
392impl<'de, 'a> SeqAccess<'de> for DeserializerSeqVisitor<'a, 'de> {
393 type Error = Error;
394
395 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
396 where
397 T: DeserializeSeed<'de>,
398 {
399 if self.de.peek_token_opt() == Some(self.end) {
400 return Ok(None);
401 }
402 self.len = self.len.map(|len| len.saturating_sub(1));
403 seed.deserialize(&mut *self.de).map(Some)
404 }
405
406 fn size_hint(&self) -> Option<usize> {
407 self.len
408 }
409}
410
411struct DeserializerMapVisitor<'a, 'de: 'a> {
414 de: &'a mut Deserializer<'de>,
415 len: Option<usize>,
416 end: Token,
417}
418
419impl<'de, 'a> MapAccess<'de> for DeserializerMapVisitor<'a, 'de> {
420 type Error = Error;
421
422 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
423 where
424 K: DeserializeSeed<'de>,
425 {
426 if self.de.peek_token_opt() == Some(self.end) {
427 return Ok(None);
428 }
429 self.len = self.len.map(|len| len.saturating_sub(1));
430 seed.deserialize(&mut *self.de).map(Some)
431 }
432
433 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
434 where
435 V: DeserializeSeed<'de>,
436 {
437 seed.deserialize(&mut *self.de)
438 }
439
440 fn size_hint(&self) -> Option<usize> {
441 self.len
442 }
443}
444
445struct DeserializerEnumVisitor<'a, 'de: 'a> {
448 de: &'a mut Deserializer<'de>,
449}
450
451impl<'de, 'a> EnumAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
452 type Error = Error;
453 type Variant = Self;
454
455 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self), Error>
456 where
457 V: DeserializeSeed<'de>,
458 {
459 match self.de.peek_token()? {
460 Token::UnitVariant { variant: v, .. }
461 | Token::NewtypeVariant { variant: v, .. }
462 | Token::TupleVariant { variant: v, .. }
463 | Token::StructVariant { variant: v, .. } => {
464 let de = v.into_deserializer();
465 let value = seed.deserialize(de)?;
466 Ok((value, self))
467 }
468 _ => {
469 let value = seed.deserialize(&mut *self.de)?;
470 Ok((value, self))
471 }
472 }
473 }
474}
475
476impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
477 type Error = Error;
478
479 fn unit_variant(self) -> Result<(), Error> {
480 match self.de.peek_token()? {
481 Token::UnitVariant { .. } => {
482 self.de.next_token()?;
483 Ok(())
484 }
485 _ => Deserialize::deserialize(self.de),
486 }
487 }
488
489 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
490 where
491 T: DeserializeSeed<'de>,
492 {
493 match self.de.peek_token()? {
494 Token::NewtypeVariant { .. } => {
495 self.de.next_token()?;
496 seed.deserialize(self.de)
497 }
498 _ => seed.deserialize(self.de),
499 }
500 }
501
502 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Error>
503 where
504 V: Visitor<'de>,
505 {
506 match self.de.peek_token()? {
507 Token::TupleVariant { len: enum_len, .. } => {
508 let token = self.de.next_token()?;
509
510 if len == enum_len {
511 self.de
512 .visit_seq(Some(len), Token::TupleVariantEnd, visitor)
513 } else {
514 Err(unexpected(token))
515 }
516 }
517 Token::Seq {
518 len: Some(enum_len),
519 } => {
520 let token = self.de.next_token()?;
521
522 if len == enum_len {
523 self.de.visit_seq(Some(len), Token::SeqEnd, visitor)
524 } else {
525 Err(unexpected(token))
526 }
527 }
528 _ => de::Deserializer::deserialize_any(self.de, visitor),
529 }
530 }
531
532 fn struct_variant<V>(
533 self,
534 fields: &'static [&'static str],
535 visitor: V,
536 ) -> Result<V::Value, Error>
537 where
538 V: Visitor<'de>,
539 {
540 match self.de.peek_token()? {
541 Token::StructVariant { len: enum_len, .. } => {
542 let token = self.de.next_token()?;
543
544 if fields.len() == enum_len {
545 self.de
546 .visit_map(Some(fields.len()), Token::StructVariantEnd, visitor)
547 } else {
548 Err(unexpected(token))
549 }
550 }
551 Token::Map {
552 len: Some(enum_len),
553 } => {
554 let token = self.de.next_token()?;
555
556 if fields.len() == enum_len {
557 self.de
558 .visit_map(Some(fields.len()), Token::MapEnd, visitor)
559 } else {
560 Err(unexpected(token))
561 }
562 }
563 _ => de::Deserializer::deserialize_any(self.de, visitor),
564 }
565 }
566}
567
568struct EnumMapVisitor<'a, 'de: 'a> {
571 de: &'a mut Deserializer<'de>,
572 variant: Option<Token>,
573 format: EnumFormat,
574}
575
576enum EnumFormat {
577 Seq,
578 Map,
579 Any,
580}
581
582impl<'a, 'de> EnumMapVisitor<'a, 'de> {
583 fn new(de: &'a mut Deserializer<'de>, variant: Token, format: EnumFormat) -> Self {
584 EnumMapVisitor {
585 de,
586 variant: Some(variant),
587 format,
588 }
589 }
590}
591
592impl<'de, 'a> MapAccess<'de> for EnumMapVisitor<'a, 'de> {
593 type Error = Error;
594
595 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
596 where
597 K: DeserializeSeed<'de>,
598 {
599 match self.variant.take() {
600 Some(Token::Str(variant)) => seed.deserialize(variant.into_deserializer()).map(Some),
601 Some(Token::Bytes(variant)) => seed
602 .deserialize(BytesDeserializer { value: variant })
603 .map(Some),
604 Some(Token::U32(variant)) => seed.deserialize(variant.into_deserializer()).map(Some),
605 Some(other) => Err(unexpected(other)),
606 None => Ok(None),
607 }
608 }
609
610 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
611 where
612 V: DeserializeSeed<'de>,
613 {
614 match self.format {
615 EnumFormat::Seq => {
616 let value = {
617 let visitor = DeserializerSeqVisitor {
618 de: self.de,
619 len: None,
620 end: Token::TupleVariantEnd,
621 };
622 seed.deserialize(SeqAccessDeserializer::new(visitor))?
623 };
624 assert_next_token(self.de, Token::TupleVariantEnd)?;
625 Ok(value)
626 }
627 EnumFormat::Map => {
628 let value = {
629 let visitor = DeserializerMapVisitor {
630 de: self.de,
631 len: None,
632 end: Token::StructVariantEnd,
633 };
634 seed.deserialize(MapAccessDeserializer::new(visitor))?
635 };
636 assert_next_token(self.de, Token::StructVariantEnd)?;
637 Ok(value)
638 }
639 EnumFormat::Any => seed.deserialize(&mut *self.de),
640 }
641 }
642}
643
644struct BytesDeserializer {
645 value: &'static [u8],
646}
647
648impl<'de> de::Deserializer<'de> for BytesDeserializer {
649 type Error = Error;
650
651 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
652 where
653 V: de::Visitor<'de>,
654 {
655 visitor.visit_bytes(self.value)
656 }
657
658 forward_to_deserialize_any! {
659 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
660 bytes byte_buf option unit unit_struct newtype_struct seq tuple
661 tuple_struct map struct enum identifier ignored_any
662 }
663}