php_literal_parser/
serde_impl.rs

1use serde::de::{
2    self, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess,
3    Visitor,
4};
5use serde::Deserialize;
6
7use crate::error::{ArrayKeyError, ArrayKeyErrorKind, ExpectToken, ResultExt, TrailingError};
8use crate::lexer::{SpannedToken, Token};
9use crate::num::ParseIntError;
10use crate::parser::{ArraySyntax, Parser};
11use crate::{Key, ParseError};
12use std::collections::VecDeque;
13use std::convert::TryFrom;
14
15type Result<T> = std::result::Result<T, ParseError>;
16
17pub struct Deserializer<'de> {
18    parser: Parser<'de>,
19    peeked: VecDeque<SpannedToken<'de>>,
20}
21
22impl<'de> Deserializer<'de> {
23    pub fn from_str(input: &'de str) -> Self {
24        Deserializer {
25            parser: Parser::new(input),
26            peeked: Default::default(),
27        }
28    }
29
30    pub fn source(&self) -> &'de str {
31        self.parser.source()
32    }
33}
34
35/// Parse a php literal
36///
37/// ## Example
38///
39/// ```rust
40/// use php_literal_parser::{from_str, Value, Key};
41/// # use std::fmt::Debug;
42/// # use std::error::Error;
43///
44/// # fn main() -> Result<(), Box<dyn Error>> {
45/// let map = from_str::<Value>(r#"["foo" => true, "nested" => ['foo' => false]]"#)?;
46///
47/// assert_eq!(map["foo"], true);
48/// assert_eq!(map["nested"]["foo"], false);
49/// # Ok(())
50/// # }
51/// ```
52///
53pub fn from_str<'a, T>(s: &'a str) -> Result<T>
54where
55    T: Deserialize<'a>,
56{
57    let mut deserializer = Deserializer::from_str(s);
58    let t = T::deserialize(&mut deserializer)?;
59    match deserializer.next_token() {
60        None
61        | Some(SpannedToken {
62            token: Token::SemiColon,
63            ..
64        }) => Ok(t),
65        Some(token) => Err(TrailingError::new(s, token.span.start..token.span.start).into()),
66    }
67}
68
69impl<'de> Deserializer<'de> {
70    fn next_token(&mut self) -> Option<SpannedToken<'de>> {
71        self.peeked.pop_front().or_else(|| self.parser.next_token())
72    }
73
74    fn peek_token(&mut self) -> Option<&SpannedToken<'de>> {
75        if self.peeked.is_empty() {
76            let next = self.next_token()?;
77            self.peeked.push_back(next)
78        }
79        self.peeked.front()
80    }
81
82    fn eat_token(&mut self) {
83        let _ = self.next_token();
84    }
85
86    fn parse_bool(&mut self) -> Result<bool> {
87        let token = self
88            .next_token()
89            .expect_token(&[Token::Bool], self.source())?;
90        self.parser.parse_bool_token(token)
91    }
92
93    fn push_peeked(&mut self, peeked: SpannedToken<'de>) {
94        self.peeked.push_front(peeked)
95    }
96
97    fn parse_unsigned<T>(&mut self) -> Result<T>
98    where
99        T: TryFrom<i64>,
100    {
101        let token = self
102            .next_token()
103            .expect_token(&[Token::Integer], self.source())?;
104        let span = token.span.clone();
105        let int = self.parser.parse_int_token(token)?;
106        if int < 0 {
107            Err(ParseIntError::UnexpectedNegative).with_span(span, self.source())
108        } else {
109            Ok(T::try_from(int)
110                .or_else(|_| Err(ParseIntError::Overflow).with_span(span, self.source()))?)
111        }
112    }
113
114    fn parse_signed<T>(&mut self) -> Result<T>
115    where
116        T: TryFrom<i64>,
117    {
118        let token = self
119            .next_token()
120            .expect_token(&[Token::Integer], self.source())?;
121        let span = token.span.clone();
122        T::try_from(self.parser.parse_int_token(token)?)
123            .or_else(|_| Err(ParseIntError::Overflow).with_span(span, self.source()))
124    }
125
126    fn parse_float(&mut self) -> Result<f64> {
127        let token = self
128            .next_token()
129            .expect_token(&[Token::Float], self.source())?;
130        self.parser.parse_float_token(token)
131    }
132
133    fn parse_string(&mut self) -> Result<String> {
134        let token = self
135            .next_token()
136            .expect_token(&[Token::LiteralString], self.source())?;
137        self.parser.parse_string_token(token)
138    }
139}
140
141impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
142    type Error = ParseError;
143
144    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
145    where
146        V: Visitor<'de>,
147    {
148        let source = self.source();
149        let peek = self.peek_token().expect_token(
150            &[
151                Token::Null,
152                Token::Bool,
153                Token::LiteralString,
154                Token::Integer,
155                Token::Float,
156                Token::Array,
157                Token::SquareOpen,
158            ],
159            source,
160        )?;
161        match peek.token {
162            Token::Null => self.deserialize_unit(visitor),
163            Token::Bool => self.deserialize_bool(visitor),
164            Token::LiteralString => self.deserialize_string(visitor),
165            Token::Integer => self.deserialize_i64(visitor),
166            Token::Float => self.deserialize_f64(visitor),
167            Token::Array | Token::SquareOpen => self.deserialize_map(visitor),
168            _ => unreachable!(),
169        }
170    }
171
172    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
173    where
174        V: Visitor<'de>,
175    {
176        visitor.visit_bool(self.parse_bool()?)
177    }
178
179    // The `parse_signed` function is generic over the integer type `T` so here
180    // it is invoked with `T=i8`. The next 8 methods are similar.
181    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
182    where
183        V: Visitor<'de>,
184    {
185        visitor.visit_i8(self.parse_signed()?)
186    }
187
188    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
189    where
190        V: Visitor<'de>,
191    {
192        visitor.visit_i16(self.parse_signed()?)
193    }
194
195    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
196    where
197        V: Visitor<'de>,
198    {
199        visitor.visit_i32(self.parse_signed()?)
200    }
201
202    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
203    where
204        V: Visitor<'de>,
205    {
206        visitor.visit_i64(self.parse_signed()?)
207    }
208
209    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
210    where
211        V: Visitor<'de>,
212    {
213        visitor.visit_u8(self.parse_unsigned()?)
214    }
215
216    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
217    where
218        V: Visitor<'de>,
219    {
220        visitor.visit_u16(self.parse_unsigned()?)
221    }
222
223    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
224    where
225        V: Visitor<'de>,
226    {
227        visitor.visit_u32(self.parse_unsigned()?)
228    }
229
230    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
231    where
232        V: Visitor<'de>,
233    {
234        visitor.visit_u64(self.parse_unsigned()?)
235    }
236
237    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
238    where
239        V: Visitor<'de>,
240    {
241        visitor.visit_f32(self.parse_float()? as f32)
242    }
243
244    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
245    where
246        V: Visitor<'de>,
247    {
248        visitor.visit_f64(self.parse_float()?)
249    }
250
251    // The `Serializer` implementation on the previous page serialized chars as
252    // single-character strings so handle that representation here.
253    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
254    where
255        V: Visitor<'de>,
256    {
257        // Parse a string, check that it is one character, call `visit_char`.
258        unimplemented!()
259    }
260
261    // Refer to the "Understanding deserializer lifetimes" page for information
262    // about the three deserialization flavors of strings in Serde.
263    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
264    where
265        V: Visitor<'de>,
266    {
267        let str = self.parse_string()?;
268        visitor.visit_str(str.as_str())
269    }
270
271    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
272    where
273        V: Visitor<'de>,
274    {
275        visitor.visit_string(self.parse_string()?)
276    }
277
278    // The `Serializer` implementation on the previous page serialized byte
279    // arrays as JSON arrays of bytes. Handle that representation here.
280    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
281    where
282        V: Visitor<'de>,
283    {
284        todo!()
285    }
286
287    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>
288    where
289        V: Visitor<'de>,
290    {
291        todo!()
292        // visitor.visit_string(self.parse_string()?.to_vec())
293    }
294
295    // An absent optional is represented as the JSON `null` and a present
296    // optional is represented as just the contained value.
297    //
298    // As commented in `Serializer` implementation, this is a lossy
299    // representation. For example the values `Some(())` and `None` both
300    // serialize as just `null`. Unfortunately this is typically what people
301    // expect when working with JSON. Other formats are encouraged to behave
302    // more intelligently if possible.
303    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
304    where
305        V: Visitor<'de>,
306    {
307        let source = self.source();
308        let token = self.peek_token().expect_token(
309            &[
310                Token::Null,
311                Token::Bool,
312                Token::LiteralString,
313                Token::Integer,
314                Token::Float,
315                Token::Array,
316                Token::SquareOpen,
317            ],
318            source,
319        )?;
320        if token.token == Token::Null {
321            let _ = self.next_token();
322            visitor.visit_none()
323        } else {
324            visitor.visit_some(self)
325        }
326    }
327
328    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
329    where
330        V: Visitor<'de>,
331    {
332        self.next_token()
333            .expect_token(&[Token::Null], self.source())?;
334        visitor.visit_unit()
335    }
336
337    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
338    where
339        V: Visitor<'de>,
340    {
341        self.deserialize_unit(visitor)
342    }
343
344    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
345    where
346        V: Visitor<'de>,
347    {
348        visitor.visit_newtype_struct(self)
349    }
350
351    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
352    where
353        V: Visitor<'de>,
354    {
355        let token = self
356            .next_token()
357            .expect_token(&[Token::Array, Token::SquareOpen], self.source())?;
358        let syntax = match token.token {
359            Token::Array => {
360                self.next_token()
361                    .expect_token(&[Token::BracketOpen], self.source())?;
362                ArraySyntax::Long
363            }
364            Token::SquareOpen => ArraySyntax::Short,
365            _ => unreachable!(),
366        };
367
368        let value = visitor.visit_seq(ArrayWalker::new(self, syntax))?;
369        Ok(value)
370    }
371
372    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
373    where
374        V: Visitor<'de>,
375    {
376        self.deserialize_seq(visitor)
377    }
378
379    fn deserialize_tuple_struct<V>(
380        self,
381        _name: &'static str,
382        _len: usize,
383        visitor: V,
384    ) -> Result<V::Value>
385    where
386        V: Visitor<'de>,
387    {
388        self.deserialize_seq(visitor)
389    }
390
391    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
392    where
393        V: Visitor<'de>,
394    {
395        let token = self
396            .next_token()
397            .expect_token(&[Token::Array, Token::SquareOpen], self.source())?;
398        let syntax = match token.token {
399            Token::Array => {
400                self.next_token()
401                    .expect_token(&[Token::BracketOpen], self.source())?;
402                ArraySyntax::Long
403            }
404            Token::SquareOpen => ArraySyntax::Short,
405            _ => unreachable!(),
406        };
407
408        let value = visitor.visit_map(ArrayWalker::new(self, syntax))?;
409        Ok(value)
410    }
411
412    fn deserialize_struct<V>(
413        self,
414        _name: &'static str,
415        _fields: &'static [&'static str],
416        visitor: V,
417    ) -> Result<V::Value>
418    where
419        V: Visitor<'de>,
420    {
421        self.deserialize_map(visitor)
422    }
423
424    fn deserialize_enum<V>(
425        self,
426        _name: &'static str,
427        _variants: &'static [&'static str],
428        visitor: V,
429    ) -> Result<V::Value>
430    where
431        V: Visitor<'de>,
432    {
433        let source = self.source();
434        let token = self.peek_token().expect_token(
435            &[Token::LiteralString, Token::Array, Token::SquareOpen],
436            source,
437        )?;
438        match token.token {
439            Token::LiteralString => visitor.visit_enum(self.parse_string()?.into_deserializer()),
440            Token::Array | Token::SquareOpen => {
441                self.eat_token();
442                let syntax = if token.token == Token::Array {
443                    self.next_token()
444                        .expect_token(&[Token::BracketOpen], self.source())?;
445                    ArraySyntax::Long
446                } else {
447                    ArraySyntax::Short
448                };
449
450                let value = visitor.visit_enum(Enum::new(self))?;
451                self.next_token()
452                    .expect_token(&[syntax.close_bracket()], self.source())?;
453                Ok(value)
454            }
455            _ => unreachable!(),
456        }
457    }
458
459    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
460    where
461        V: Visitor<'de>,
462    {
463        self.deserialize_str(visitor)
464    }
465
466    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
467    where
468        V: Visitor<'de>,
469    {
470        self.deserialize_any(visitor)
471    }
472}
473
474struct ArrayWalker<'source, 'a> {
475    de: &'a mut Deserializer<'source>,
476    next_int_key: i64,
477    syntax: ArraySyntax,
478    done: bool,
479}
480
481impl<'source, 'a> ArrayWalker<'source, 'a> {
482    pub fn new(de: &'a mut Deserializer<'source>, syntax: ArraySyntax) -> Self {
483        ArrayWalker {
484            de,
485            next_int_key: 0,
486            syntax,
487            done: false,
488        }
489    }
490
491    fn source(&self) -> &'source str {
492        self.de.source()
493    }
494}
495
496impl<'de> SeqAccess<'de> for ArrayWalker<'de, '_> {
497    type Error = ParseError;
498
499    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
500    where
501        T: DeserializeSeed<'de>,
502    {
503        let source = self.source();
504        if self.done {
505            return Ok(None);
506        }
507
508        let token = self.de.next_token().expect_token(
509            &[
510                Token::Bool,
511                Token::Integer,
512                Token::Float,
513                Token::LiteralString,
514                Token::Null,
515                Token::Array,
516                Token::SquareOpen,
517                self.syntax.close_bracket(),
518            ],
519            source,
520        )?;
521
522        if token.token == self.syntax.close_bracket() {
523            self.done = true;
524            return Ok(None);
525        }
526
527        let value_token = if token.token.is_valid_array_key() {
528            let next = self.de.peek_token();
529
530            if next.map(|t| t.token) == Some(Token::Arrow) {
531                self.de.eat_token();
532                let key_span = token.span.clone();
533                let key = self.de.parser.parse_array_key(token)?;
534                match key {
535                    Key::Int(key) if key == self.next_int_key => Ok(()),
536                    Key::Int(_) => Err(ParseError::UnexpectedArrayKey(ArrayKeyError::new(
537                        ArrayKeyErrorKind::NonConsecutive,
538                        self.source(),
539                        key_span,
540                    ))),
541                    _ => Err(ParseError::UnexpectedArrayKey(ArrayKeyError::new(
542                        ArrayKeyErrorKind::IntegerExpected,
543                        self.source(),
544                        key_span,
545                    ))),
546                }?;
547                self.next_int_key += 1;
548                self.de.next_token().expect_token(
549                    &[
550                        Token::Bool,
551                        Token::Integer,
552                        Token::Float,
553                        Token::LiteralString,
554                        Token::Null,
555                        Token::Array,
556                        Token::SquareOpen,
557                    ],
558                    self.source(),
559                )?
560            } else {
561                token
562            }
563        } else {
564            token
565        };
566
567        // Deserialize an array element.
568        self.de.push_peeked(value_token);
569        let result = seed.deserialize(&mut *self.de).map(Some)?;
570
571        let comma_or_end = self
572            .de
573            .next_token()
574            .expect_token(&[Token::Comma, self.syntax.close_bracket()], source)?;
575        if comma_or_end.token == self.syntax.close_bracket() {
576            self.done = true;
577        }
578
579        Ok(result)
580    }
581}
582
583impl<'de> MapAccess<'de> for ArrayWalker<'de, '_> {
584    type Error = ParseError;
585
586    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
587    where
588        K: DeserializeSeed<'de>,
589    {
590        if self.done {
591            return Ok(None);
592        }
593
594        let token = self.de.next_token().expect_token(
595            &[
596                Token::Bool,
597                Token::Integer,
598                Token::Float,
599                Token::LiteralString,
600                Token::Null,
601                self.syntax.close_bracket(),
602                // below is only when this token is a value with implicit key, not a when the token is a key
603                Token::Array,
604                Token::SquareOpen,
605            ],
606            self.source(),
607        )?;
608
609        if token.token == self.syntax.close_bracket() {
610            self.done = true;
611            return Ok(None);
612        }
613
614        let next = self.de.next_token().ok_or_else(|| {
615            Option::<SpannedToken>::None
616                .expect_token(
617                    &[Token::Arrow, Token::Comma, self.syntax.close_bracket()],
618                    self.source(),
619                )
620                .unwrap_err()
621        })?;
622
623        match next.token {
624            Token::Arrow => {
625                // now we know it's a map key, the expected token is a bit more strict
626                let token = token.expect_token(
627                    &[
628                        Token::Bool,
629                        Token::Integer,
630                        Token::Float,
631                        Token::LiteralString,
632                        Token::Null,
633                        self.syntax.close_bracket(),
634                    ],
635                    self.source(),
636                )?;
637                // Deserialize a map key.
638                if let Key::Int(int_key) = self.de.parser.parse_array_key(token.clone())? {
639                    self.next_int_key = int_key + 1;
640                }
641                self.de.push_peeked(token);
642                seed.deserialize(&mut *self.de).map(Some)
643            }
644            _ => {
645                // implicit key
646                let key = self.next_int_key;
647                self.next_int_key += 1;
648                self.de.push_peeked(next);
649                self.de.push_peeked(token);
650                seed.deserialize(key.to_string().into_deserializer())
651                    .map(Some)
652            }
653        }
654    }
655
656    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
657    where
658        V: DeserializeSeed<'de>,
659    {
660        let source = self.source();
661        self.de.peek_token().expect_token(
662            &[
663                Token::Bool,
664                Token::Integer,
665                Token::Float,
666                Token::LiteralString,
667                Token::Null,
668                Token::Array,
669                Token::SquareOpen,
670            ],
671            source,
672        )?;
673
674        // Deserialize a map key.
675        let value = seed.deserialize(&mut *self.de)?;
676
677        let next = self
678            .de
679            .next_token()
680            .expect_token(&[Token::Comma, self.syntax.close_bracket()], self.source())?;
681
682        if next.token == self.syntax.close_bracket() {
683            self.done = true;
684        }
685        Ok(value)
686    }
687}
688
689struct Enum<'a, 'de: 'a> {
690    de: &'a mut Deserializer<'de>,
691}
692
693impl<'a, 'de> Enum<'a, 'de> {
694    fn new(de: &'a mut Deserializer<'de>) -> Self {
695        Enum { de }
696    }
697
698    fn source(&self) -> &'de str {
699        self.de.source()
700    }
701}
702
703// `EnumAccess` is provided to the `Visitor` to give it the ability to determine
704// which variant of the enum is supposed to be deserialized.
705//
706// Note that all enum deserialization methods in Serde refer exclusively to the
707// "externally tagged" enum representation.
708impl<'de> EnumAccess<'de> for Enum<'_, 'de> {
709    type Error = ParseError;
710    type Variant = Self;
711
712    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
713    where
714        V: DeserializeSeed<'de>,
715    {
716        let val = seed.deserialize(&mut *self.de)?;
717        self.de
718            .next_token()
719            .expect_token(&[Token::Arrow], self.source())?;
720        Ok((val, self))
721    }
722}
723
724// `VariantAccess` is provided to the `Visitor` to give it the ability to see
725// the content of the single variant that it decided to deserialize.
726impl<'de> VariantAccess<'de> for Enum<'_, 'de> {
727    type Error = ParseError;
728
729    fn unit_variant(self) -> Result<()> {
730        self.de
731            .next_token()
732            .expect_token(&[Token::LiteralString], self.source())?;
733        Ok(())
734    }
735
736    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
737    where
738        T: DeserializeSeed<'de>,
739    {
740        seed.deserialize(self.de)
741    }
742
743    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
744    where
745        V: Visitor<'de>,
746    {
747        de::Deserializer::deserialize_seq(self.de, visitor)
748    }
749
750    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
751    where
752        V: Visitor<'de>,
753    {
754        de::Deserializer::deserialize_map(self.de, visitor)
755    }
756}
757
758////////////////////////////////////////////////////////////////////////////////
759
760#[cfg(test)]
761mod tests {
762    use serde_derive::Deserialize;
763
764    fn from_str<'a, T>(source: &'a str) -> super::Result<T>
765    where
766        T: serde::Deserialize<'a>,
767    {
768        match super::from_str(source) {
769            Ok(res) => Ok(res),
770            Err(err) => {
771                eprintln!("{err}");
772                Err(err)
773            }
774        }
775    }
776
777    #[test]
778    fn test_vec() {
779        let j = r#"["a","b"]"#;
780        let expected: Vec<String> = vec!["a".to_string(), "b".to_string()];
781        assert_eq!(expected, from_str::<Vec<String>>(j).unwrap());
782    }
783
784    #[test]
785    fn test_vec_explicit_keys() {
786        let j = r#"[0=>"a", 1=>"b"]"#;
787        let expected: Vec<String> = vec!["a".to_string(), "b".to_string()];
788        assert_eq!(expected, from_str::<Vec<String>>(j).unwrap());
789    }
790
791    #[test]
792    fn test_struct() {
793        #[derive(Deserialize, PartialEq, Debug)]
794        struct Test {
795            int: u32,
796            seq: Vec<String>,
797        }
798
799        let j = r#"["int"=>1,"seq"=>["a","b"]]"#;
800        let expected = Test {
801            int: 1,
802            seq: vec!["a".to_owned(), "b".to_owned()],
803        };
804        assert_eq!(expected, from_str(j).unwrap());
805    }
806
807    #[test]
808    fn test_struct_nested() {
809        #[derive(Deserialize, PartialEq, Debug)]
810        struct Inner {
811            a: f32,
812            b: bool,
813        }
814
815        #[derive(Deserialize, PartialEq, Debug)]
816        struct Test {
817            int: u32,
818            nested: Inner,
819        }
820
821        let j = r#"["int"=>1,"nested"=>["a" => 1.0, "b" => false]]"#;
822        let expected = Test {
823            int: 1,
824            nested: Inner { a: 1.0, b: false },
825        };
826        assert_eq!(expected, from_str(j).unwrap());
827    }
828
829    #[test]
830    fn test_enum() {
831        #[derive(Deserialize, PartialEq, Debug)]
832        enum E {
833            Unit,
834            Newtype1(u32),
835            Newtype2(u32),
836            Tuple(u32, u32),
837            Struct { a: u32 },
838        }
839
840        let j = r#""Unit""#;
841        let expected = E::Unit;
842        assert_eq!(expected, from_str(j).unwrap());
843
844        let j = r#"["Newtype1"=>1]"#;
845        let expected = E::Newtype1(1);
846        assert_eq!(expected, from_str(j).unwrap());
847
848        let j = r#"["Newtype2"=>1]"#;
849        let expected = E::Newtype2(1);
850        assert_eq!(expected, from_str(j).unwrap());
851
852        let j = r#"["Tuple"=>[1,2]]"#;
853        let expected = E::Tuple(1, 2);
854        assert_eq!(expected, from_str(j).unwrap());
855
856        let j = r#"["Struct"=>["a"=>1]]"#;
857        let expected = E::Struct { a: 1 };
858        assert_eq!(expected, from_str(j).unwrap());
859    }
860}
php_literal_parser/serde_impl.rs

php_literal_parser/
serde_impl.rs
