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