teo_parser/ast/
literals.rs

1use regex::Regex;
2use crate::value::value::Value;
3use crate::ast::argument_list::ArgumentList;
4use crate::ast::expression::Expression;
5use crate::ast::identifier::Identifier;
6use crate::{declare_container_node, declare_node, impl_container_node_defaults, impl_node_defaults, node_child_fn, node_children_iter, node_children_iter_fn, node_optional_child_fn};
7use crate::ast::named_expression::NamedExpression;
8use crate::ast::punctuations::Punctuation;
9use crate::format::Writer;
10use crate::traits::write::Write;
11
12declare_node!(NumericLiteral, pub(crate) value: Value, pub(crate) display: String);
13
14impl_node_defaults!(NumericLiteral);
15
16impl Write for NumericLiteral {
17    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
18        writer.write_content(self, self.display.as_str());
19    }
20}
21
22declare_node!(StringLiteral, pub(crate) value: String, pub(crate) display: String);
23
24impl_node_defaults!(StringLiteral);
25
26impl Write for StringLiteral {
27    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
28        writer.write_content(self, self.display.as_str());
29    }
30}
31
32declare_node!(RegexLiteral, pub(crate) value: Regex, pub(crate) display: String);
33
34impl_node_defaults!(RegexLiteral);
35
36impl Write for RegexLiteral {
37    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
38        writer.write_content(self, self.display.as_str());
39    }
40}
41
42declare_node!(BoolLiteral, pub(crate) value: bool);
43
44impl_node_defaults!(BoolLiteral);
45
46impl Write for BoolLiteral {
47    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
48        writer.write_content(self, if self.value { "true" } else { "false" });
49    }
50}
51
52declare_node!(NullLiteral);
53
54impl_node_defaults!(NullLiteral);
55
56impl Write for NullLiteral {
57    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
58        writer.write_content(self, "null")
59    }
60}
61
62declare_container_node!(EnumVariantLiteral,
63    pub(crate) identifier: usize,
64    pub(crate) argument_list: Option<usize>,
65);
66
67impl_container_node_defaults!(EnumVariantLiteral);
68
69impl EnumVariantLiteral {
70
71    node_child_fn!(identifier, Identifier);
72
73    node_optional_child_fn!(argument_list, ArgumentList);
74
75    pub fn unwrap_enumerable_enum_member_strings(&self) -> Option<Vec<&str>> {
76        Some(vec![self.identifier().name()])
77    }
78
79    pub fn unwrap_enumerable_enum_member_string(&self) -> Option<&str> {
80        Some(self.identifier().name())
81    }
82}
83
84impl Write for EnumVariantLiteral {
85    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
86        writer.write_children(self, self.children.values())
87    }
88}
89
90declare_container_node!(TupleLiteral, pub(crate) expressions: Vec<usize>);
91
92impl_container_node_defaults!(TupleLiteral);
93
94node_children_iter!(TupleLiteral, Expression, TupleLiteralExpressionsIter, expressions);
95
96impl TupleLiteral {
97
98    node_children_iter_fn!(expressions, TupleLiteralExpressionsIter);
99}
100
101impl Write for TupleLiteral {
102    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
103        writer.write_children(self, self.children.values())
104    }
105}
106
107declare_container_node!(ArrayLiteral, pub(crate) expressions: Vec<usize>);
108
109impl_container_node_defaults!(ArrayLiteral);
110
111node_children_iter!(ArrayLiteral, Expression, ArrayLiteralExpressionsIter, expressions);
112
113impl ArrayLiteral {
114
115    node_children_iter_fn!(expressions, ArrayLiteralExpressionsIter);
116
117    pub fn unwrap_enumerable_enum_member_strings(&self) -> Option<Vec<&str>> {
118        let mut result = vec![];
119        for expression in self.expressions() {
120            if let Some(r) = expression.unwrap_enumerable_enum_member_string() {
121                result.push(r);
122            }
123        }
124        Some(result)
125    }
126
127    pub fn unwrap_enumerable_enum_member_string(&self) -> Option<&str> {
128        if self.expressions.len() < 1 {
129            None
130        } else {
131            self.expressions().next().unwrap().unwrap_enumerable_enum_member_string()
132        }
133    }
134}
135
136impl Write for ArrayLiteral {
137    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
138        writer.write_children(self, self.children.values())
139    }
140}
141
142declare_container_node!(DictionaryLiteral,
143    pub(crate) expressions: Vec<usize>,
144    pub(crate) namespace_path: Vec<usize>,
145    pub(crate) is_config_field: bool,
146    pub(crate) close_block: usize,
147);
148
149impl_container_node_defaults!(DictionaryLiteral);
150
151node_children_iter!(DictionaryLiteral, NamedExpression, DictionaryLiteralExpressionsIter, expressions);
152
153impl DictionaryLiteral {
154
155    node_children_iter_fn!(expressions, DictionaryLiteralExpressionsIter);
156
157    node_child_fn!(close_block, Punctuation);
158
159}
160
161impl Write for DictionaryLiteral {
162    fn write<'a>(&'a self, writer: &mut Writer<'a>) {
163        writer.write_children(self, self.children.values())
164    }
165}
teo_parser/ast/literals.rs

teo_parser/ast/
literals.rs
