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