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