datex_core/visitor/expression/
visitable.rs

1use crate::ast::expressions::Apply;
2use crate::ast::expressions::{
3    BinaryOperation, CallableDeclaration, ComparisonOperation, Conditional,
4    CreateRef, DatexExpression, DatexExpressionData, Deref, DerefAssignment,
5    GenericInstantiation, List, Map, PropertyAccess, PropertyAssignment,
6    RemoteExecution, SlotAssignment, Statements, TypeDeclaration,
7    UnaryOperation, VariableAssignment, VariableDeclaration,
8};
9use crate::visitor::VisitAction;
10use crate::visitor::expression::ExpressionVisitor;
11use crate::visitor::type_expression::visitable::VisitableTypeExpression;
12
13pub type ExpressionVisitResult<E> = Result<VisitAction<DatexExpression>, E>;
14
15pub trait VisitableExpression<E> {
16    fn walk_children(
17        &mut self,
18        visitor: &mut impl ExpressionVisitor<E>,
19    ) -> Result<(), E>;
20}
21
22impl<E> VisitableExpression<E> for BinaryOperation {
23    fn walk_children(
24        &mut self,
25        visitor: &mut impl ExpressionVisitor<E>,
26    ) -> Result<(), E> {
27        visitor.visit_datex_expression(&mut self.left)?;
28        visitor.visit_datex_expression(&mut self.right)?;
29        Ok(())
30    }
31}
32
33impl<E> VisitableExpression<E> for Statements {
34    fn walk_children(
35        &mut self,
36        visitor: &mut impl ExpressionVisitor<E>,
37    ) -> Result<(), E> {
38        for item in &mut self.statements {
39            visitor.visit_datex_expression(item)?;
40        }
41        Ok(())
42    }
43}
44impl<E> VisitableExpression<E> for List {
45    fn walk_children(
46        &mut self,
47        visitor: &mut impl ExpressionVisitor<E>,
48    ) -> Result<(), E> {
49        for item in &mut self.items {
50            visitor.visit_datex_expression(item)?;
51        }
52        Ok(())
53    }
54}
55impl<E> VisitableExpression<E> for Map {
56    fn walk_children(
57        &mut self,
58        visitor: &mut impl ExpressionVisitor<E>,
59    ) -> Result<(), E> {
60        for (_key, value) in &mut self.entries {
61            visitor.visit_datex_expression(value)?;
62        }
63        Ok(())
64    }
65}
66impl<E> VisitableExpression<E> for Conditional {
67    fn walk_children(
68        &mut self,
69        visitor: &mut impl ExpressionVisitor<E>,
70    ) -> Result<(), E> {
71        visitor.visit_datex_expression(&mut self.condition)?;
72        visitor.visit_datex_expression(&mut self.then_branch)?;
73        if let Some(else_branch) = &mut self.else_branch {
74            visitor.visit_datex_expression(else_branch)?;
75        }
76        Ok(())
77    }
78}
79impl<E> VisitableExpression<E> for VariableDeclaration {
80    fn walk_children(
81        &mut self,
82        visitor: &mut impl ExpressionVisitor<E>,
83    ) -> Result<(), E> {
84        //visitor.visit_identifier(&mut self.name, self.)?;
85        visitor.visit_datex_expression(&mut self.init_expression)?;
86        if let Some(type_annotation) = &mut self.type_annotation {
87            visitor.visit_type_expression(type_annotation)?;
88        }
89        Ok(())
90    }
91}
92impl<E> VisitableExpression<E> for VariableAssignment {
93    fn walk_children(
94        &mut self,
95        visitor: &mut impl ExpressionVisitor<E>,
96    ) -> Result<(), E> {
97        visitor.visit_datex_expression(&mut self.expression)?;
98        Ok(())
99    }
100}
101impl<E> VisitableExpression<E> for UnaryOperation {
102    fn walk_children(
103        &mut self,
104        visitor: &mut impl ExpressionVisitor<E>,
105    ) -> Result<(), E> {
106        visitor.visit_datex_expression(&mut self.expression)?;
107        Ok(())
108    }
109}
110impl<E> VisitableExpression<E> for TypeDeclaration {
111    fn walk_children(
112        &mut self,
113        visitor: &mut impl ExpressionVisitor<E>,
114    ) -> Result<(), E> {
115        visitor.visit_type_expression(&mut self.definition)?;
116        Ok(())
117    }
118}
119impl<E> VisitableExpression<E> for ComparisonOperation {
120    fn walk_children(
121        &mut self,
122        visitor: &mut impl ExpressionVisitor<E>,
123    ) -> Result<(), E> {
124        visitor.visit_datex_expression(&mut self.left)?;
125        visitor.visit_datex_expression(&mut self.right)?;
126        Ok(())
127    }
128}
129impl<E> VisitableExpression<E> for DerefAssignment {
130    fn walk_children(
131        &mut self,
132        visitor: &mut impl ExpressionVisitor<E>,
133    ) -> Result<(), E> {
134        visitor.visit_datex_expression(&mut self.assigned_expression)?;
135        visitor.visit_datex_expression(&mut self.deref_expression)?;
136        Ok(())
137    }
138}
139impl<E> VisitableExpression<E> for Apply {
140    fn walk_children(
141        &mut self,
142        visitor: &mut impl ExpressionVisitor<E>,
143    ) -> Result<(), E> {
144        visitor.visit_datex_expression(&mut self.base)?;
145        for arg in &mut self.arguments {
146            visitor.visit_datex_expression(arg)?;
147        }
148        Ok(())
149    }
150}
151
152impl<E> VisitableExpression<E> for PropertyAccess {
153    fn walk_children(
154        &mut self,
155        visitor: &mut impl ExpressionVisitor<E>,
156    ) -> Result<(), E> {
157        visitor.visit_datex_expression(&mut self.base)?;
158        visitor.visit_datex_expression(&mut self.property)?;
159        Ok(())
160    }
161}
162
163impl<E> VisitableExpression<E> for GenericInstantiation {
164    fn walk_children(
165        &mut self,
166        visitor: &mut impl ExpressionVisitor<E>,
167    ) -> Result<(), E> {
168        visitor.visit_datex_expression(&mut self.base)?;
169        for arg in &mut self.generic_arguments {
170            visitor.visit_type_expression(arg)?;
171        }
172        Ok(())
173    }
174}
175
176impl<E> VisitableExpression<E> for RemoteExecution {
177    fn walk_children(
178        &mut self,
179        visitor: &mut impl ExpressionVisitor<E>,
180    ) -> Result<(), E> {
181        visitor.visit_datex_expression(&mut self.left)?;
182        visitor.visit_datex_expression(&mut self.right)?;
183        Ok(())
184    }
185}
186impl<E> VisitableExpression<E> for SlotAssignment {
187    fn walk_children(
188        &mut self,
189        visitor: &mut impl ExpressionVisitor<E>,
190    ) -> Result<(), E> {
191        visitor.visit_datex_expression(&mut self.expression)?;
192        Ok(())
193    }
194}
195impl<E> VisitableExpression<E> for CallableDeclaration {
196    fn walk_children(
197        &mut self,
198        visitor: &mut impl ExpressionVisitor<E>,
199    ) -> Result<(), E> {
200        if let Some(return_type) = &mut self.return_type {
201            visitor.visit_type_expression(return_type)?;
202        }
203        for (_, param_type) in &mut self.parameters {
204            visitor.visit_type_expression(param_type)?;
205        }
206        visitor.visit_datex_expression(&mut self.body)?;
207        Ok(())
208    }
209}
210
211impl<E> VisitableExpression<E> for Deref {
212    fn walk_children(
213        &mut self,
214        visitor: &mut impl ExpressionVisitor<E>,
215    ) -> Result<(), E> {
216        visitor.visit_datex_expression(&mut self.expression)?;
217        Ok(())
218    }
219}
220
221impl<E> VisitableExpression<E> for CreateRef {
222    fn walk_children(
223        &mut self,
224        visitor: &mut impl ExpressionVisitor<E>,
225    ) -> Result<(), E> {
226        visitor.visit_datex_expression(&mut self.expression)?;
227        Ok(())
228    }
229}
230
231impl<E> VisitableExpression<E> for PropertyAssignment {
232    fn walk_children(
233        &mut self,
234        visitor: &mut impl ExpressionVisitor<E>,
235    ) -> Result<(), E> {
236        visitor.visit_datex_expression(&mut self.base)?;
237        visitor.visit_datex_expression(&mut self.property)?;
238        visitor.visit_datex_expression(&mut self.assigned_expression)?;
239        Ok(())
240    }
241}
242
243impl<E> VisitableExpression<E> for DatexExpression {
244    fn walk_children(
245        &mut self,
246        visitor: &mut impl ExpressionVisitor<E>,
247    ) -> Result<(), E> {
248        match &mut self.data {
249            DatexExpressionData::PropertyAssignment(property_assignment) => {
250                property_assignment.walk_children(visitor)
251            }
252            DatexExpressionData::BinaryOperation(op) => {
253                op.walk_children(visitor)
254            }
255            DatexExpressionData::Statements(statements) => {
256                statements.walk_children(visitor)
257            }
258            DatexExpressionData::List(list) => list.walk_children(visitor),
259            DatexExpressionData::Map(map) => map.walk_children(visitor),
260            DatexExpressionData::Conditional(conditional) => {
261                conditional.walk_children(visitor)
262            }
263            DatexExpressionData::VariableDeclaration(variable_declaration) => {
264                variable_declaration.walk_children(visitor)
265            }
266            DatexExpressionData::VariableAssignment(variable_assignment) => {
267                variable_assignment.walk_children(visitor)
268            }
269            DatexExpressionData::TypeDeclaration(type_declaration) => {
270                type_declaration.walk_children(visitor)
271            }
272            DatexExpressionData::TypeExpression(type_expression) => {
273                type_expression.walk_children(visitor)
274            }
275            DatexExpressionData::CallableDeclaration(function_declaration) => {
276                function_declaration.walk_children(visitor)
277            }
278            DatexExpressionData::CreateRef(create_ref) => {
279                create_ref.walk_children(visitor)
280            }
281            DatexExpressionData::Deref(datex_expression) => {
282                datex_expression.walk_children(visitor)
283            }
284            DatexExpressionData::SlotAssignment(slot_assignment) => {
285                slot_assignment.walk_children(visitor)
286            }
287            DatexExpressionData::ComparisonOperation(comparison_operation) => {
288                comparison_operation.walk_children(visitor)
289            }
290            DatexExpressionData::DerefAssignment(deref_assignment) => {
291                deref_assignment.walk_children(visitor)
292            }
293            DatexExpressionData::UnaryOperation(unary_operation) => {
294                unary_operation.walk_children(visitor)
295            }
296            DatexExpressionData::Apply(apply_chain) => {
297                apply_chain.walk_children(visitor)
298            }
299            DatexExpressionData::PropertyAccess(property_access) => {
300                property_access.walk_children(visitor)
301            }
302            DatexExpressionData::GenericInstantiation(
303                generic_instantiation,
304            ) => generic_instantiation.walk_children(visitor),
305            DatexExpressionData::RemoteExecution(remote_execution) => {
306                remote_execution.walk_children(visitor)
307            }
308
309            DatexExpressionData::Noop
310            | DatexExpressionData::NativeImplementationIndicator
311            | DatexExpressionData::VariantAccess(_)
312            | DatexExpressionData::PointerAddress(_)
313            | DatexExpressionData::VariableAccess(_)
314            | DatexExpressionData::GetReference(_)
315            | DatexExpressionData::Slot(_)
316            | DatexExpressionData::Placeholder
317            | DatexExpressionData::Recover
318            | DatexExpressionData::Null
319            | DatexExpressionData::Boolean(_)
320            | DatexExpressionData::Text(_)
321            | DatexExpressionData::Decimal(_)
322            | DatexExpressionData::TypedDecimal(_)
323            | DatexExpressionData::Integer(_)
324            | DatexExpressionData::TypedInteger(_)
325            | DatexExpressionData::Identifier(_)
326            | DatexExpressionData::Endpoint(_) => Ok(()),
327        }
328    }
329}
datex_core/visitor/expression/visitable.rs

datex_core/visitor/expression/
visitable.rs
