lib/grammar/ast/
literal.rs

1use pest::iterators::Pair;
2use serde::ser::{Serialize, Serializer};
3use serde::Serialize as SerializeDerive;
4
5// use crate::grammar::ast::string::String;
6use crate::grammar::parser::Rule;
7
8#[derive(Debug, Clone, Eq, PartialEq, SerializeDerive)]
9#[serde(untagged)]
10pub enum LiteralTypes {
11    Array(Vec<Literal>),
12    String(String),
13    Boolean(bool),
14    Number(usize),
15}
16
17#[derive(Debug, Clone, Eq, PartialEq)]
18pub struct Literal {
19    pub inner: LiteralTypes,
20}
21
22impl Default for Literal {
23    fn default() -> Self {
24        Self {
25            inner: LiteralTypes::String(String::default()),
26        }
27    }
28}
29
30impl Serialize for Literal {
31    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
32    where
33        S: Serializer,
34    {
35        self.inner.serialize(serializer)
36    }
37}
38
39impl<'r> From<Pair<'r, Rule>> for Literal {
40    fn from(pair: Pair<'r, Rule>) -> Self {
41        let inner = match pair.as_rule() {
42            Rule::r#true | Rule::r#false => {
43                let span = pair.as_span().as_str();
44
45                match span.parse::<bool>() {
46                    Ok(v) => LiteralTypes::Boolean(v),
47                    Err(_) => {
48                        unreachable!("Could not parse string to boolean")
49                    }
50                }
51            }
52            Rule::number => {
53                let span = pair.as_span().as_str();
54
55                match span.parse::<u32>() {
56                    Ok(n) => LiteralTypes::Number(n as usize),
57                    Err(e) => {
58                        unreachable!("Could not parse string to number: {:?}", e)
59                    }
60                }
61            }
62            Rule::string | Rule::multi_line_string => {
63                let inner = pair.into_inner().next().unwrap().as_span().as_str();
64                LiteralTypes::String(String::from(inner))
65            }
66            Rule::array => {
67                let mut result = Vec::new();
68
69                for p in pair.clone().into_inner() {
70                    result.push(Literal::from(p));
71                }
72
73                LiteralTypes::Array(result)
74            }
75            _ => {
76                unreachable!("Unexpected {:?} literal type", pair.as_rule())
77            }
78        };
79
80        Self { inner }
81    }
82}
83
84impl Literal {
85    pub fn inner(&self) -> LiteralTypes {
86        self.inner.clone()
87    }
88}
89
90// impl Serialize for Literal {
91//     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
92//     where
93//         S: Serializer,
94//     {
95//         match &self.inner {
96//             LiteralTypes::Array(a) => {
97//                 let mut seq = serializer.serialize_seq(Some(a.len()))?;
98//                 for e in a {
99//                     seq.serialize_element(e)?;
100//                 }
101//                 seq.end()
102//             }
103//             LiteralTypes::String(s) => serializer.serialize_str(s),
104//             LiteralTypes::Boolean(_) => serializer.serialize_str("hello"),
105//             LiteralTypes::Number(_) => serializer.serialize_str("hello"),
106//         }
107
108//         let mut map = serializer.serialize_map(Some(1))?;
109//         map.serialize_entry("type", "string")?;
110//         map.serialize_entry("value", &self.inner)?;
111//         map.end()
112
113//         serializer.serialize_i32(40)
114//         seq.serialize_element(e)
115//         serializer.serialize_str("hello")
116//     }
117// }
118
119// impl Serialize for LiteralTypes {
120//     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
121//     where
122//         S: Serializer,
123//     {
124//         match &self {
125//             LiteralTypes::Array(a) => {
126//                 let mut seq = serializer.serialize_seq(Some(a.len()))?;
127//                 for e in a {
128//                     seq.serialize_element(e)?;
129//                 }
130//                 seq.end()
131//             }
132//             LiteralTypes::String(s) => serializer.serialize_str(s),
133//             LiteralTypes::Boolean(_) => serializer.serialize_str("hello"),
134//             LiteralTypes::Number(_) => serializer.serialize_str("hello"),
135//         }
136
137//         // serializer.serialize_i32(40)
138//         // let mut map = serializer.serialize_map(Some(1))?;
139//         // map.serialize_entry("type", "string")?;
140//         // map.serialize_entry("value", &self)?;
141//         // map.end()
142//     }
143// }
lib/grammar/ast/literal.rs

lib/grammar/ast/
literal.rs
