(refs #7322) Implemented visitors for CHRStatement
[simantics/platform.git] / bundles / org.simantics.scl.compiler / src / org / simantics / scl / compiler / elaboration / expressions / StandardExpressionTransformer.java
1 package org.simantics.scl.compiler.elaboration.expressions;
2
3 import org.simantics.scl.compiler.elaboration.chr.CHRLiteral;
4 import org.simantics.scl.compiler.elaboration.chr.CHRRule;
5 import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
6 import org.simantics.scl.compiler.elaboration.equation.EqBasic;
7 import org.simantics.scl.compiler.elaboration.equation.EqGuard;
8 import org.simantics.scl.compiler.elaboration.equation.Equation;
9 import org.simantics.scl.compiler.elaboration.equation.EquationVisitor;
10 import org.simantics.scl.compiler.elaboration.expressions.accessor.ExpressionAccessor;
11 import org.simantics.scl.compiler.elaboration.expressions.block.BindStatement;
12 import org.simantics.scl.compiler.elaboration.expressions.block.CHRStatement;
13 import org.simantics.scl.compiler.elaboration.expressions.block.GuardStatement;
14 import org.simantics.scl.compiler.elaboration.expressions.block.IncludeStatement;
15 import org.simantics.scl.compiler.elaboration.expressions.block.LetStatement;
16 import org.simantics.scl.compiler.elaboration.expressions.block.RuleStatement;
17 import org.simantics.scl.compiler.elaboration.expressions.block.Statement;
18 import org.simantics.scl.compiler.elaboration.expressions.block.StatementVisitor;
19 import org.simantics.scl.compiler.elaboration.expressions.list.ListAssignment;
20 import org.simantics.scl.compiler.elaboration.expressions.list.ListGenerator;
21 import org.simantics.scl.compiler.elaboration.expressions.list.ListGuard;
22 import org.simantics.scl.compiler.elaboration.expressions.list.ListQualifier;
23 import org.simantics.scl.compiler.elaboration.expressions.list.ListQualifierTransformer;
24 import org.simantics.scl.compiler.elaboration.expressions.list.ListSeq;
25 import org.simantics.scl.compiler.elaboration.expressions.list.ListThen;
26 import org.simantics.scl.compiler.elaboration.expressions.records.FieldAssignment;
27 import org.simantics.scl.compiler.elaboration.query.QAlternative;
28 import org.simantics.scl.compiler.elaboration.query.QAtom;
29 import org.simantics.scl.compiler.elaboration.query.QConjunction;
30 import org.simantics.scl.compiler.elaboration.query.QDisjunction;
31 import org.simantics.scl.compiler.elaboration.query.QExists;
32 import org.simantics.scl.compiler.elaboration.query.QIf;
33 import org.simantics.scl.compiler.elaboration.query.QMapping;
34 import org.simantics.scl.compiler.elaboration.query.QNegation;
35 import org.simantics.scl.compiler.elaboration.query.Query;
36 import org.simantics.scl.compiler.elaboration.query.pre.QPreBinds;
37 import org.simantics.scl.compiler.elaboration.query.pre.QPreEquals;
38 import org.simantics.scl.compiler.elaboration.query.pre.QPreExists;
39 import org.simantics.scl.compiler.elaboration.query.pre.QPreGuard;
40
41 public class StandardExpressionTransformer implements
42 ExpressionTransformer, QueryTransformer, ListQualifierTransformer, StatementVisitor,
43 EquationVisitor {
44
45     @Override
46     public Expression transform(EAmbiguous expression) {
47         return expression;
48     }
49
50     @Override
51     public Expression transform(EApply expression) {
52         expression.function = expression.function.accept(this);
53         for(int i=0;i<expression.parameters.length;++i)
54             expression.parameters[i] = expression.parameters[i].accept(this);
55         return expression;
56     }
57
58     @Override
59     public Expression transform(EApplyType expression) {
60         expression.expression = expression.expression.accept(this);
61         return expression;
62     }
63
64     @Override
65     public Expression transform(EAsPattern expression) {
66         expression.pattern = expression.pattern.accept(this);
67         return expression;
68     }
69
70     @Override
71     public Expression transform(EBinary expression) {
72         expression.left = expression.left.accept(this);
73         for(EBinaryRightSide rs : expression.rights)
74             rs.right = rs.right.accept(this);
75         return expression;
76     }
77
78     @Override
79     public Expression transform(EBind expression) {
80         expression.pattern = expression.pattern.accept(this);
81         expression.value = expression.value.accept(this);
82         expression.in = expression.in.accept(this);
83         return expression;
84     }
85
86     @Override
87     public Expression transform(EViewPattern expression) {
88         expression.expression = expression.expression.accept(this);
89         expression.pattern = expression.pattern.accept(this);
90         return expression;
91     }
92     
93     @Override
94     public Expression transform(EBlock expression) {
95         for(Statement statement : expression.statements)
96             statement.accept(this);
97         return expression;
98     }
99     
100     @Override
101     public void visit(BindStatement statement) {
102         statement.pattern = statement.pattern.accept(this);
103         statement.value = statement.value.accept(this);
104     }
105     
106     @Override
107     public void visit(GuardStatement statement) {
108         statement.value = statement.value.accept(this);        
109     }
110     
111     @Override
112     public void visit(LetStatement statement) {
113         statement.pattern = statement.pattern.accept(this);
114         statement.value = statement.value.accept(this);
115     }
116     
117     @Override
118     public void visit(RuleStatement statement) {
119         statement.head = statement.head.accept(this);
120         statement.body = statement.body.accept(this);
121     }
122
123     @Override
124     public void visit(IncludeStatement statement) {
125         statement.value = statement.value.accept(this);
126     }
127     
128     public void transform(CHRRuleset ruleset) {
129         for(CHRRule rule : ruleset.rules) {
130             for(CHRLiteral lit : rule.head.literals)
131                 for(int i=0;i<lit.parameters.length;++i)
132                     lit.parameters[i] = lit.parameters[i].accept(this);
133             for(CHRLiteral lit : rule.body.literals)
134                 for(int i=0;i<lit.parameters.length;++i)
135                     lit.parameters[i] = lit.parameters[i].accept(this);
136         }
137     }
138     
139     @Override
140     public Expression transform(ECHRRuleset expression) {
141         expression.in = expression.in.accept(this);
142         transform(expression.ruleset);
143         return expression;
144     }
145     
146     @Override
147     public Expression transform(ECHRRulesetConstructor expression) {
148         transform(expression.ruleset);
149         return expression;
150     }
151
152     @Override
153     public Expression transform(EConstant expression) {
154         return expression;
155     }
156
157     @Override
158     public Expression transform(EEnforce expression) {
159         expression.query = expression.query.accept(this);
160         return expression;
161     }
162
163     @Override
164     public Expression transform(EError expression) {
165         return expression;
166     }
167
168     @Override
169     public Expression transform(EExternalConstant expression) {
170         return expression;
171     }
172
173     @Override
174     public Expression transform(EFieldAccess expression) {
175         expression.parent = expression.parent.accept(this);
176         if(expression.accessor instanceof ExpressionAccessor) {
177                 ExpressionAccessor expAcc = (ExpressionAccessor)expression.accessor;
178                 expAcc.fieldName = expAcc.fieldName.accept(this);
179         }
180         return expression;
181     }
182
183     @Override
184     public Expression transform(EGetConstraint expression) {
185         return expression;
186     }
187
188     @Override
189     public Expression transform(EIf expression) {
190         expression.condition = expression.condition.accept(this);
191         expression.then_ = expression.then_.accept(this);
192         if(expression.else_ != null)
193             expression.else_ = expression.else_.accept(this);
194         return expression;
195     }
196
197     @Override
198     public Expression transform(EIntegerLiteral expression) {
199         return expression;
200     }
201
202     protected void transformCases(Case[] cases) {
203         for(Case case_ : cases) {
204             for(int i=0;i<case_.patterns.length;++i)
205                 case_.patterns[i] = case_.patterns[i].accept(this);
206             case_.value = case_.value.accept(this);
207         }
208     }
209     
210     @Override
211     public Expression transform(ELambda expression) {
212         transformCases(expression.cases);
213         return expression;
214     }
215
216     @Override
217     public Expression transform(ELambdaType expression) {
218         expression.value = expression.value.accept(this);
219         return expression;
220     }
221
222     @Override
223     public Expression transform(ELet expression) {
224         expression.in = expression.in.accept(this);
225         for(Assignment assign : expression.assignments) {
226             assign.pattern = assign.pattern.accept(this);
227             assign.value = assign.value.accept(this);
228         }
229         return expression;
230     }
231
232     @Override
233     public Expression transform(EListComprehension expression) {
234         expression.head = expression.head.accept(this);
235         expression.qualifier =  expression.qualifier.accept(this);
236         return expression;
237     }
238
239     @Override
240     public Expression transform(EListLiteral expression) {
241         for(int i=0;i<expression.components.length;++i)
242             expression.components[i] = expression.components[i].accept(this);
243         return expression;
244     }
245
246     @Override
247     public Expression transform(ELiteral expression) {
248         return expression;
249     }
250
251     @Override
252     public Expression transform(EMatch expression) {
253         for(int i=0;i<expression.scrutinee.length;++i)
254             expression.scrutinee[i] = expression.scrutinee[i].accept(this);
255         transformCases(expression.cases);
256         return expression;
257     }
258
259     @Override
260     public Expression transform(EPlaceholder expression) {
261         expression.expression = expression.expression.accept(this);
262         return expression;
263     }
264
265     @Override
266     public Expression transform(EPreLet expression) {
267         for(LetStatement statement : expression.assignments) {
268             statement.pattern = statement.pattern.accept(this);
269             statement.value = statement.value.accept(this);
270         }
271         expression.in = expression.in.accept(this);
272         return expression;
273     }
274
275     @Override
276     public Expression transform(EPreRuleset expression) {
277         for(RuleStatement rule : expression.statements) {
278             rule.body = rule.body.accept(this);
279             rule.head = rule.head.accept(this);
280         }
281         expression.in = expression.in.accept(this);
282         return expression;
283     }
284
285     @Override
286     public Expression transform(ECoveringBranchPoint expression) {
287         expression.expression = expression.expression.accept(this);
288         return expression;
289     }
290
291     @Override
292     public Expression transform(ERange expression) {
293         expression.from = expression.from.accept(this);
294         expression.to = expression.to.accept(this);
295         return expression;
296     }
297
298     @Override
299     public Expression transform(ERealLiteral expression) {
300         return expression;
301     }
302
303     @Override
304     public Expression transform(ERecord expression) {
305         for(FieldAssignment field : expression.fields)
306             if(field.value != null)
307                 field.value = field.value.accept(this);
308         return expression;
309     }
310
311     @Override
312     public Expression transform(ERuleset expression) {
313         for(ERuleset.DatalogRule rule : expression.rules) {
314             rule.body = rule.body.accept(this);
315             for(int i=0;i<rule.headParameters.length;++i)
316                 rule.headParameters[i] = rule.headParameters[i].accept(this);
317         }
318         expression.in = expression.in.accept(this);
319         return expression;
320     }
321
322     @Override
323     public Expression transform(ESelect expression) {
324         expression.query = expression.query.accept(this);
325         expression.expression = expression.expression.accept(this);
326         return expression;
327     }
328
329     @Override
330     public Expression transform(ESimpleLambda expression) {
331         expression.value = expression.value.accept(this);
332         return expression;
333     }
334
335     @Override
336     public Expression transform(ESimpleLet expression) {
337         expression.value = expression.value.accept(this);
338         expression.in = expression.in.accept(this);
339         return expression;
340     }
341
342     @Override
343     public Expression transform(EStringLiteral expression) {
344         return expression;
345     }
346
347     @Override
348     public Expression transform(ETransformation expression) {
349         expression.seed = expression.seed.accept(this);
350         return expression;
351     }
352
353     @Override
354     public Expression transform(ETypeAnnotation expression) {
355         expression.value = expression.value.accept(this);
356         return expression;
357     }
358
359     @Override
360     public Expression transform(EVar expression) {
361         return expression;
362     }
363
364     @Override
365     public Expression transform(EVariable expression) {
366         return expression;
367     }
368
369     @Override
370     public Expression transform(EWhen expression) {
371         expression.query = expression.query.accept(this);
372         expression.action = expression.action.accept(this);
373         return expression;
374     }
375
376     @Override
377     public Expression transform(GuardedExpressionGroup expression) {
378         for(GuardedExpression ge : expression.expressions) {
379             for(int i=0;i<ge.guards.length;++i)
380                 ge.guards[i] = ge.guards[i].accept(this);
381             ge.value = ge.value.accept(this);
382         }
383         return expression;
384     }
385
386     @Override
387     public ListQualifier transform(ListAssignment qualifier) {
388         qualifier.pattern = qualifier.pattern.accept(this);
389         qualifier.value = qualifier.value.accept(this);
390         return qualifier;
391     }
392
393     @Override
394     public ListQualifier transform(ListGenerator qualifier) {
395         qualifier.pattern = qualifier.pattern.accept(this);
396         qualifier.value = qualifier.value.accept(this);
397         return qualifier;
398     }
399
400     @Override
401     public ListQualifier transform(ListGuard qualifier) {
402         qualifier.condition = qualifier.condition.accept(this);
403         return qualifier;
404     }
405
406     @Override
407     public ListQualifier transform(ListSeq qualifier) {
408         qualifier.a = qualifier.a.accept(this);
409         qualifier.b = qualifier.b.accept(this);
410         return qualifier;
411     }
412
413     @Override
414     public ListQualifier transform(ListThen qualifier) {
415         qualifier.left = qualifier.left.accept(this);
416         qualifier.transformer = qualifier.transformer.accept(this);
417         if(qualifier.by != null)
418             qualifier.by = qualifier.by.accept(this);
419         return qualifier;
420     }
421
422     @Override
423     public Query transform(QAlternative query) {
424         for(int i=0;i<query.queries.length;++i)
425             query.queries[i] = query.queries[i].accept(this);
426         return query;
427     }
428
429     @Override
430     public Query transform(QAtom query) {
431         for(int i=0;i<query.parameters.length;++i)
432             query.parameters[i] = query.parameters[i].accept(this);
433         return query;
434     }
435
436     @Override
437     public Query transform(QConjunction query) {
438         for(int i=0;i<query.queries.length;++i)
439             query.queries[i] = query.queries[i].accept(this);
440         return query;
441     }
442
443     @Override
444     public Query transform(QDisjunction query) {
445         for(int i=0;i<query.queries.length;++i)
446             query.queries[i] = query.queries[i].accept(this);
447         return query;
448     }
449
450     @Override
451     public Query transform(QExists query) {
452         query.query = query.query.accept(this);
453         return query;
454     }
455
456     @Override
457     public Query transform(QIf query) {
458         query.condition = query.condition.accept(this);
459         query.thenQuery = query.thenQuery.accept(this);
460         query.elseQuery = query.elseQuery.accept(this);
461         return query;
462     }
463
464     @Override
465     public Query transform(QMapping query) {
466         for(int i=0;i<query.parameters.length;++i)
467             query.parameters[i] = query.parameters[i].accept(this);
468         return query;
469     }
470
471     @Override
472     public Query transform(QNegation query) {
473         query.query = query.query.accept(this);
474         return query;
475     }
476
477     @Override
478     public Query transform(QPreBinds query) {
479         query.left = query.left.accept(this);
480         query.right = query.right.accept(this);
481         return query;
482     }
483
484     @Override
485     public Query transform(QPreEquals query) {
486         query.left = query.left.accept(this);
487         query.right = query.right.accept(this);
488         return query;
489     }
490
491     @Override
492     public Query transform(QPreExists query) {
493         query.query = query.query.accept(this);
494         return query;
495     }
496
497     @Override
498     public Query transform(QPreGuard query) {
499         query.guard = query.guard.accept(this);
500         return query;
501     }
502
503     @Override
504     public Expression transform(EEquations expression) {
505         for(Equation equation : expression.equations)
506             equation.accept(this);
507         return expression;
508     }
509
510     @Override
511     public void visit(EqBasic equation) {
512         equation.left =  equation.left.accept(this);
513         equation.right = equation.right.accept(this);
514     }
515
516     @Override
517     public void visit(EqGuard equation) {
518         equation.guard =  equation.guard.accept(this);
519     }
520
521     @Override
522     public void visit(CHRStatement statement) {
523         for(int i=0;i<statement.body.length;++i)
524             statement.body[i] = statement.body[i].accept(this);
525         for(int i=0;i<statement.head.length;++i)
526             statement.head[i] = statement.head[i].accept(this);
527     }
528
529 }