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